diff --git a/CHANGELOG b/CHANGELOG new file mode 100644 --- /dev/null +++ b/CHANGELOG @@ -0,0 +1,234 @@ +1.9.4 --> 1.9.5 +=============== + +* Fix a bug where deriving clauses for GADT-style data declarations + were not properly indented. + +* Pretty-printing patterns is now more accurate in inserting (and not + inserting) parentheses when needed. + +** 1.9.x + +1.9.3 --> 1.9.4 +=============== + +* Pretty-printer now inserts parentheses in clever places when + printing kinds. + +* Pretty-printing expressions is now far more accurate in inserting + (and not inserting) parentheses when needed. + +* Pretty-printing negative expressions no longer inserts a superfluous + space between the - and the expression. + +1.9.2 --> 1.9.3 +=============== + +* Constructors for newtype declarations must now have exactly one + argument. This is only when using the classic syntax, not with + GADT-style syntax. + +* Fix a bug where preceding commas in tuple sections were counted + one too few. + +1.9.1 --> 1.9.2 +=============== + +* Fix a bug with pretty-printing lexer tokens. + +* Fix a bug where non-colon TypeOperators could not be used in + prefix mode. + +1.9.0 --> 1.9.1 +=============== + +* Export parseFileContentsWithExts from .Exts. + + +1.8.2 --> 1.9.0 +=============== + +* OptionPragma is renamed to the more descriptive ModulePragma, + and adds a constructor AnnModulePragma for handling ANN pragmas + preceding module header. + +* Add instances for Eq/Ord/Data/Typeable for Fixity. + +* Add 'parseFileWithComments' and 'parseFileContentsWithComments' + to L.H.Exts . + +* More informative error messages when HSX tags are mismatched. + + +** 1.8.x + +1.8.1 --> 1.8.2 +=============== + +* Don't insert redundant parentheses around record constructions + and updates. + +1.8.0 --> 1.8.1 +=============== + +* Fix three bugs with the handling of ANN. I must have been really + tired when implementing that support. + +1.7.2 --> 1.8.0 +=============== + +* Add an instance Show Fixity (derived). + +* Support for the new ANN and INLINE_CONLIKE pragmas. + +* Export knownExtensions from .Extension. + +* Remove support for CFILES and INCLUDE pragmas. The support wasn't + correct anyway, as it assumed the pragmas appeared at the top of + files. As CFILES/INCLUDE pragmas can (and do) appear anywhere, + there's no hope to support them in the AST. Better to remove the + support altogether. Files with CFILES/INCLUDE pragmas can still + be parsed of course, but those pragmas will be handled as comments. + +* Parsing with ignoreLinePragmas = False now correctly updates the + file name. + +* Allow the whole SPECIALISE/INLINE family of pragmas in instance + declarations. The InsInline constructor is removed, and is now + represented by InsDecl (InlineSig ...). + +* Fix a bug with line numbering and quasi quotes, and a similar one + with line numbering and CDATA. + +* Fix a few minor bugs in the exactPrinter. + +* Fix the strange handling of so called strings in LINE pragmas. + +** 1.7.x + +1.7.1 --> 1.7.2 +=============== + +* Fixes a bug in lexing LINE pragmas (used when ignoreLinePragmas + is set to False). + +1.7.0 --> 1.7.1 +=============== + +* UnicodeSyntax now also enables the forall symbol (U+2200). + +1.6.1 --> 1.7.0 +=============== + +* Operators defined on the form + + (a `op` b) c = ... + + could not be handled by the (annotated) AST, nor the parser. I had to + change the definition of the AST node for InfixMatch to allow a list + of right-hand subpatterns, i.e. + + InfixMatch l (Pat l) (Name l) (Pat l) ... + + has become + + InfixMatch l (Pat l) (Name l) [Pat l] ... + + I also had an epiphany and fixed the issue that would arise with + exact printing of prefix definitions including parentheses, so + that now works too! + +** 1.6.x + +1.6.0 --> 1.6.1 +=============== + +* UnicodeSyntax now works not only for identifiers, but also for + ->, <- and =>, as well as Arrows arrows and kind stars. + +1.5.3 --> 1.6.0 +=============== + +* (=~=) turns out to be too general at Functor (for intuitive and not + technical reasons), so is specialised to Annotated to closer mirror + the original intention. + +* applyFixities is hoisted to a monad, and now fails on ambiguous infix + expressions. + +** 1.5.x + +1.5.2 --> 1.5.3 +=============== + +* Several small bug fixes in the exact printer, and fail more gracefully + if the number of srcInfoPoints doesn't match the needs of the node. + +1.5.1 --> 1.5.2 +=============== + +* Fix a bug in the exact printer that made it always print the first token + at position (0,0). + +* In fixing the above, Annotated is now a superclass of ExactP. It was already + a superclass in spirit, and nothing can break from this since ExactP is only + exported abstractly. + +1.5.0 --> 1.5.1 +=============== + +* The pretty printer now introduces parentheses for non-atomic arguments to + function application. Note that infix applications are left untouched, no + parentheses will be inserted there, as it is assumed that fixities are + already properly resolved. + +* Fix a bug in the pretty printer where view patterns and n+k patterns were + not properly parenthesised. + +1.4.0 --> 1.5.0 +=============== + +* Add support for acting on LINE pragmas while parsing, i.e. updating the source + position according to info given in LINE pragmas. This is done conditionally + based on a new flag ignoreLinePragmas in the ParseMode, hence the need to + increase the major version. + +** 1.4.x + +1.3.5 --> 1.4.0 +=============== + +* The AST node for Proc in the simple AST is changed to include a SrcLoc argument, + to make it consistent with similar nodes e.g. Lambda. This is specifically needed + for transformation of patterns in HSX. + + +** 1.3.x + +1.3.4 --> 1.3.5 +=============== + +* Added an entry point in the parser for statements, and an instance Parseable Stmt + to go with it. + +* Ensured that .Annotated exports all relevant parseXXX(WithYYY) functions. + +1.3.3 --> 1.3.4 +=============== + +* Operator fixities are now resolved in patterns. + +1.3.2 --> 1.3.3 +=============== + +* Fixes a bug where qualified keywords are rejected even if the extension that + enables the keyword in question is not turned on. + + +1.3.0 --> 1.3.2 +=============== + +(Let's forget 1.3.1 ever existed.) + +* Fix a bug where declarations of infix operators were not properly merged as FunBinds. + diff --git a/Test/Runner.hs b/Test/Runner.hs new file mode 100644 --- /dev/null +++ b/Test/Runner.hs @@ -0,0 +1,74 @@ +-- | Use "runhaskell Setup.hs test" or "cabal test" to run these tests. +-- Particular files may be selected by supplying their names as arguments. +module Main where + +import Language.Haskell.Exts.Annotated +import System.IO +import Control.Monad +import Data.List +import Data.Char +import System.Directory +import System.Environment (getArgs) +import System.Exit (exitFailure) +import System.FilePath + + +main :: IO () +main = go =<< getArgs + + +-- | Run the selected tests - or all of them if the supplied list is empty +go :: [FilePath] -> IO () +go testsToRun = do + hSetBuffering stdout NoBuffering + files <- if null testsToRun then getDirectoryContents examplesDir else return testsToRun + putStrLn "Testing parser:" + src <- liftM (map (head . words) . lines) . readFile $ "Test" "failing.txt" + results <- sequence [check (x `elem` src) (examplesDir x) | x <- files, not $ "." `isPrefixOf` x] + putStrLn "\nAll parsing tests completed!\n" + putStrLn "Testing exact printer:" + pSrc <- liftM (map (head . words) . lines) . readFile $ "Test" "printFail.txt" + pResults <- sequence [roundTrip (x `elem` pSrc) (examplesDir x) + | x <- files, x `notElem` src, not $ "." `isPrefixOf` x] + putStrLn "\nAll printing tests completed!\n" + unless (all id $ results ++ pResults) exitFailure + + +-- | Where all the tests are to be found +examplesDir :: FilePath +examplesDir = "Test" "examples" + + +-- | Runs the test, and returns True unless there is an unexpected result +check :: Bool -> FilePath -> IO Bool +check expected file = do + res <- parseFile file + case res of + ParseOk x | expected -> putStrLn ("\n") >> return False + | otherwise -> putChar '.' >> return True + err | expected -> putChar '!' >> return True + | otherwise -> putStrLn ("\nFailure when parsing " ++ show file ++ "\n" ++ show err) >> return False + + +roundTrip :: Bool -> FilePath -> IO Bool +roundTrip expected file = do + fc <- readFile file + pr <- parseFileWithComments (defaultParseMode { parseFilename = file }) file + case pr of + ParseOk (ast,cs) -> do + let res = exactPrint ast cs + xs = dropWhile (uncurry (==)) + $ zip (map (reverse . dropWhile isSpace . reverse) $ lines fc) + (map (reverse . dropWhile isSpace . reverse) $ lines res) + case xs of + [] | expected -> putStrLn ("\n") >> return False + | otherwise -> putChar '.' >> return True + (lfc, lres):_ + | expected -> putChar '!' >> return True + | otherwise -> do + putStrLn $ "Result of print does not match input when printing " ++ show file + putStrLn $ "First unmatching lines are (line length):" + putStrLn $ " Input (" ++ show (length lfc) ++ "): " ++ lfc + putStrLn $ " Result (" ++ show (length lres) ++ "): " ++ lres + return False + err -> putStrLn ("\nFailure when parsing " ++ show file ++ "\n" ++ show err) >> return False diff --git a/Test/examples/ArrowLayout.hs b/Test/examples/ArrowLayout.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ArrowLayout.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE Arrows #-} +module ArrowLayout where + +exp = proc () -> do + rec let e = 1 + i + i <- integral -< e + returnA -< e diff --git a/Test/examples/Attributes.hs b/Test/examples/Attributes.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Attributes.hs @@ -0,0 +1,2181 @@ +{- | + Module : Data.GraphViz.Attributes + Description : Definition of the Graphviz attributes. + Copyright : (c) Matthew Sackman, Ivan Lazar Miljenovic + License : 3-Clause BSD-style + Maintainer : Ivan.Miljenovic@gmail.com + + This module defines the various attributes that different parts of + a Graphviz graph can have. These attributes are based on the + documentation found at: + + + For more information on usage, etc. please see that document. + + A summary of known current constraints\/limitations\/differences: + + * There might still be a few cases where quotes are still not + escaped/parsed correctly; if you find such a situation, please + let me know; however, you should be able to use 'String' values + directly without having to worry about when quotes are required + or extra escaping of quote characters as 'PrintDot' and + 'ParseDot' instances for 'String' should take care of that + for you. + + * Note that for an edge, in /Dot/ parlance if the edge goes from + /A/ to /B/, then /A/ is the tail node and /B/ is the head node + (since /A/ is at the tail end of the arrow). + + * ColorList and PointfList are defined as actual lists (but + 'LayerList' is not). Note that for the Color 'Attribute' for + node values, only a single Color is valid; edges are allowed + multiple colors with one spline/arrow per color in the list (but + you must have at least one 'Color' in the list). This might be + changed in future. + + * Style is implemented as a list of 'StyleItem' values; note that + empty lists are not allowed. + + * A lot of values have a possible value of @none@. These now + have custom constructors. In fact, most constructors have been + expanded upon to give an idea of what they represent rather than + using generic terms. + + * @PointF@ and 'Point' have been combined, and feature support for pure + 'Int'-based co-ordinates as well as 'Double' ones (i.e. no floating + point-only points for Point). The optional '!' and third value + for Point are not available. + + * 'Rect' uses two 'Point' values to denote the lower-left and + top-right corners. + + * The two 'LabelLoc' attributes have been combined. + + * The defined 'LayerSep' is not used to parse 'LayerRange' or + 'LayerList'; the default (@[' ', ':', '\t']@) is instead used. + + * @SplineType@ has been replaced with @['Spline']@. + + * Only polygon-based 'Shape's are available. + + * 'PortPos' only has the 'CompassPoint' option, not + @PortName[:CompassPoint]@ (since record shapes aren't allowed, + and parsing HTML-like labels could be problematic). + + * Not every 'Attribute' is fully documented/described. However, + all those which have specific allowed values should be covered. + + * Deprecated 'Overlap' algorithms are not defined. + + * The global @Orientation@ attribute is not defined, as it is + difficult to distinguish from the node-based 'Orientation' + 'Attribute'; also, its behaviour is duplicated by 'Rotate'. + + -} +module Data.GraphViz.Attributes + ( -- * The actual /Dot/ attributes. + Attribute(..) + , Attributes + -- ** Validity functions on @Attribute@ values. + , usedByGraphs + , usedBySubGraphs + , usedByClusters + , usedByNodes + , usedByEdges + -- * Value types for @Attribute@s. + , EscString + , URL(..) + , ArrowType(..) + , AspectType(..) + , Rect(..) + , ClusterMode(..) + , DirType(..) + , DEConstraints(..) + , DPoint(..) + , ModeType(..) + , Model(..) + , Label(..) + , Point(..) + , Overlap(..) + , LayerRange(..) + , LayerID(..) + , LayerList(..) + , OutputMode(..) + , Pack(..) + , PackMode(..) + , Pos(..) + , EdgeType(..) + , PageDir(..) + , Spline(..) + , QuadType(..) + , Root(..) + , RankType(..) + , RankDir(..) + , Shape(..) + , SmoothType(..) + , StartType(..) + , STStyle(..) + , StyleItem(..) + , StyleName(..) + , PortPos(..) + , CompassPoint(..) + , ViewPort(..) + , FocusType(..) + , VerticalPlacement(..) + , ScaleType(..) + , Justification(..) + , Ratios(..) + , module Data.GraphViz.Attributes.Colors + -- * Types representing the Dot grammar for @ArrowType@. + , ArrowShape(..) + , ArrowModifier(..) + , ArrowFill(..) + , ArrowSide(..) + -- ** Default @ArrowType@ aliases. + -- *** The 9 primitive @ArrowShape@s. + , box + , crow + , diamond + , dotArrow + , inv + , noArrow + , normal + , tee + , vee + -- *** 5 derived Arrows. + , oDot + , invDot + , invODot + , oBox + , oDiamond + -- *** 5 supported cases for backwards compatibility + , eDiamond + , openArr + , halfOpen + , emptyArr + , invEmpty + -- ** @ArrowModifier@ instances + , noMods + , openMod + -- * Other exported functions\/values + , defLayerSep + , notLayerSep + ) where + +import Data.GraphViz.Attributes.Colors +import Data.GraphViz.Util +import Data.GraphViz.Parsing +import Data.GraphViz.Printing + +import Data.Char(toLower) +import Data.Maybe(isJust) +import Control.Arrow(first) +import Control.Monad(liftM, liftM2) + +-- ----------------------------------------------------------------------------- + +{- | + + These attributes have been implemented in a /permissive/ manner: + that is, rather than split them up based on which type of value + they are allowed, they have all been included in the one data type, + with functions to determine if they are indeed valid for what + they're being applied to. + + To interpret the /Valid for/ listings: + + [@G@] Valid for Graphs. + + [@C@] Valid for Clusters. + + [@S@] Valid for Sub-Graphs (and also Clusters). + + [@N@] Valid for Nodes. + + [@E@] Valid for Edges. + + The /Default/ listings are those that the various Graphviz commands + use if that 'Attribute' isn't specified (in cases where this is + /none/, this is equivalent to a 'Nothing' value; that is, no value + is used). The /Parsing Default/ listings represent what value is + used (i.e. corresponds to 'True') when the 'Attribute' name is + listed on its own in /Dot/ source code. +-} +data Attribute + = Damping Double -- ^ /Valid for/: G; /Default/: @0.99@; /Minimum/: @0.0@; /Notes/: neato only + | K Double -- ^ /Valid for/: GC; /Default/: @0.3@; /Minimum/: @0@; /Notes/: sfdp, fdp only + | URL URL -- ^ /Valid for/: ENGC; /Default/: none; /Notes/: svg, postscript, map only + | ArrowHead ArrowType -- ^ /Valid for/: E; /Default/: @'normal'@ + | ArrowSize Double -- ^ /Valid for/: E; /Default/: @1.0@; /Minimum/: @0.0@ + | ArrowTail ArrowType -- ^ /Valid for/: E; /Default/: @'normal'@ + | Aspect AspectType -- ^ /Valid for/: G; /Notes/: dot only + | Bb Rect -- ^ /Valid for/: G; /Notes/: write only + | BgColor Color -- ^ /Valid for/: GC; /Default/: X11Color 'Transparent' + | Center Bool -- ^ /Valid for/: G; /Default/: @'False'@; /Parsing Default/: 'True' + | Charset String -- ^ /Valid for/: G; /Default/: @\"UTF-8\"@ + | ClusterRank ClusterMode -- ^ /Valid for/: G; /Default/: @'Local'@; /Notes/: dot only + | ColorScheme ColorScheme -- ^ /Valid for/: ENCG; /Default/: @'X11'@ + | Color [Color] -- ^ /Valid for/: ENC; /Default/: @X11Color 'Black'@ + | Comment String -- ^ /Valid for/: ENG; /Default/: @\"\"@ + | Compound Bool -- ^ /Valid for/: G; /Default/: @'False'@; /Parsing Default/: 'True'; /Notes/: dot only + | Concentrate Bool -- ^ /Valid for/: G; /Default/: @'False'@; /Parsing Default/: 'True' + | Constraint Bool -- ^ /Valid for/: E; /Default/: @'True'@; /Parsing Default/: 'True'; /Notes/: dot only + | Decorate Bool -- ^ /Valid for/: E; /Default/: @'False'@; /Parsing Default/: 'True' + | DefaultDist Double -- ^ /Valid for/: G; /Default/: @1+(avg. len)*sqrt(|V|)@; /Minimum/: @epsilon@; /Notes/: neato only + | Dimen Int -- ^ /Valid for/: G; /Default/: @2@; /Minimum/: @2@; /Notes/: sfdp, fdp, neato only + | Dim Int -- ^ /Valid for/: G; /Default/: @2@; /Minimum/: @2@; /Notes/: sfdp, fdp, neato only + | Dir DirType -- ^ /Valid for/: E; /Default/: @'Forward'@ (directed), @'NoDir'@ (undirected) + | DirEdgeConstraints DEConstraints -- ^ /Valid for/: G; /Default/: @'NoConstraints'@; /Parsing Default/: 'EdgeConstraints'; /Notes/: neato only + | Distortion Double -- ^ /Valid for/: N; /Default/: @0.0@; /Minimum/: @-100.0@ + | DPI Double -- ^ /Valid for/: G; /Default/: @96.0@, @0.0@; /Notes/: svg, bitmap output only; \"resolution\" is a synonym + | EdgeURL URL -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: svg, map only + | EdgeTarget EscString -- ^ /Valid for/: E; /Default/: none; /Notes/: svg, map only + | EdgeTooltip EscString -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: svg, cmap only + | Epsilon Double -- ^ /Valid for/: G; /Default/: @.0001 * # nodes@ (@mode == 'KK'@), @.0001@ (@mode == 'Major'@); /Notes/: neato only + | ESep DPoint -- ^ /Valid for/: G; /Default/: @+3@; /Notes/: not dot + | FillColor Color -- ^ /Valid for/: NC; /Default/: @X11Color 'LightGray'@ (nodes), @X11Color 'Black'@ (clusters) + | FixedSize Bool -- ^ /Valid for/: N; /Default/: @'False'@; /Parsing Default/: 'True' + | FontColor Color -- ^ /Valid for/: ENGC; /Default/: @X11Color 'Black'@ + | FontName String -- ^ /Valid for/: ENGC; /Default/: @\"Times-Roman\"@ + | FontNames String -- ^ /Valid for/: G; /Default/: @\"\"@; /Notes/: svg only + | FontPath String -- ^ /Valid for/: G; /Default/: system-dependent + | FontSize Double -- ^ /Valid for/: ENGC; /Default/: @14.0@; /Minimum/: @1.0@ + | Group String -- ^ /Valid for/: N; /Default/: @\"\"@; /Notes/: dot only + | HeadURL URL -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: svg, map only + | HeadClip Bool -- ^ /Valid for/: E; /Default/: @'True'@; /Parsing Default/: 'True' + | HeadLabel Label -- ^ /Valid for/: E; /Default/: @\"\"@ + | HeadPort PortPos -- ^ /Valid for/: E; /Default/: @'PP' 'CenterPoint'@ + | HeadTarget EscString -- ^ /Valid for/: E; /Default/: none; /Notes/: svg, map only + | HeadTooltip EscString -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: svg, cmap only + | Height Double -- ^ /Valid for/: N; /Default/: @0.5@; /Minimum/: @0.02@ + | ID Label -- ^ /Valid for/: GNE; /Default/: @\"\"@; /Notes/: svg, postscript, map only + | Image String -- ^ /Valid for/: N; /Default/: @\"\"@ + | ImageScale ScaleType -- ^ /Valid for/: N; /Default/: @'NoScale'@; /Parsing Default/: 'UniformScale' + | LabelURL URL -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: svg, map only + | LabelAngle Double -- ^ /Valid for/: E; /Default/: @-25.0@; /Minimum/: @-180.0@ + | LabelDistance Double -- ^ /Valid for/: E; /Default/: @1.0@; /Minimum/: @0.0@ + | LabelFloat Bool -- ^ /Valid for/: E; /Default/: @'False'@; /Parsing Default/: 'True' + | LabelFontColor Color -- ^ /Valid for/: E; /Default/: @X11Color 'Black'@ + | LabelFontName String -- ^ /Valid for/: E; /Default/: @\"Times-Roman\"@ + | LabelFontSize Double -- ^ /Valid for/: E; /Default/: @14.0@; /Minimum/: @1.0@ + | LabelJust Justification -- ^ /Valid for/: GC; /Default/: @'JCenter'@ + | LabelLoc VerticalPlacement -- ^ /Valid for/: GCN; /Default/: @'VTop'@ (clusters), @'VBottom'@ (root graphs), @'VCenter'@ (nodes) + | LabelTarget EscString -- ^ /Valid for/: E; /Default/: none; /Notes/: svg, map only + | LabelTooltip EscString -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: svg, cmap only + | Label Label -- ^ /Valid for/: ENGC; /Default/: @'StrLabel' \"\N\"@ (nodes), @'StrLabel' \"\"@ (otherwise) + | Landscape Bool -- ^ /Valid for/: G; /Default/: @'False'@; /Parsing Default/: 'True' + | LayerSep String -- ^ /Valid for/: G; /Default/: @\" :\t\"@ + | Layers LayerList -- ^ /Valid for/: G; /Default/: @\"\"@ + | Layer LayerRange -- ^ /Valid for/: EN; /Default/: @\"\"@ + | Layout String -- ^ /Valid for/: G; /Default/: @\"\"@ + | Len Double -- ^ /Valid for/: E; /Default/: @1.0@ (neato), @0.3@ (fdp); /Notes/: fdp, neato only + | LevelsGap Double -- ^ /Valid for/: G; /Default/: @0.0@; /Notes/: neato only + | Levels Int -- ^ /Valid for/: G; /Default/: @MAXINT@; /Minimum/: @0@; /Notes/: sfdp only + | LHead String -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: dot only + | LPos Point -- ^ /Valid for/: EGC; /Notes/: write only + | LTail String -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: dot only + | Margin DPoint -- ^ /Valid for/: NG; /Default/: device-dependent + | MaxIter Int -- ^ /Valid for/: G; /Default/: @100 * # nodes@ (@mode == 'KK'@), @200@ (@mode == 'Major'@), @600@ (fdp); /Notes/: fdp, neato only + | MCLimit Double -- ^ /Valid for/: G; /Default/: @1.0@; /Notes/: dot only + | MinDist Double -- ^ /Valid for/: G; /Default/: @1.0@; /Minimum/: @0.0@; /Notes/: circo only + | MinLen Int -- ^ /Valid for/: E; /Default/: @1@; /Minimum/: @0@; /Notes/: dot only + | Model Model -- ^ /Valid for/: G; /Default/: @'ShortPath'@; /Notes/: neato only + | Mode ModeType -- ^ /Valid for/: G; /Default/: @'Major'@; /Notes/: neato only + | Mosek Bool -- ^ /Valid for/: G; /Default/: @'False'@; /Parsing Default/: 'True'; /Notes/: neato only; requires the Mosek software + | NodeSep Double -- ^ /Valid for/: G; /Default/: @0.25@; /Minimum/: @0.02@; /Notes/: dot only + | NoJustify Bool -- ^ /Valid for/: GCNE; /Default/: @'False'@; /Parsing Default/: 'True' + | Normalize Bool -- ^ /Valid for/: G; /Default/: @'False'@; /Parsing Default/: 'True'; /Notes/: not dot + | Nslimit1 Double -- ^ /Valid for/: G; /Notes/: dot only + | Nslimit Double -- ^ /Valid for/: G; /Notes/: dot only + | Ordering String -- ^ /Valid for/: G; /Default/: @\"\"@; /Notes/: dot only + | Orientation Double -- ^ /Valid for/: N; /Default/: @0.0@; /Minimum/: @360.0@ + | OutputOrder OutputMode -- ^ /Valid for/: G; /Default/: @'BreadthFirst'@ + | OverlapScaling Double -- ^ /Valid for/: G; /Default/: @-4@; /Minimum/: @-1.0e10@; /Notes/: prism only + | Overlap Overlap -- ^ /Valid for/: G; /Default/: @'KeepOverlaps'@; /Parsing Default/: 'KeepOverlaps'; /Notes/: not dot + | PackMode PackMode -- ^ /Valid for/: G; /Default/: @'PackNode'@; /Notes/: not dot + | Pack Pack -- ^ /Valid for/: G; /Default/: @'False'@; /Parsing Default/: 'DoPack'; /Notes/: not dot + | Pad DPoint -- ^ /Valid for/: G; /Default/: @'DVal' 0.0555@ (4 points) + | PageDir PageDir -- ^ /Valid for/: G; /Default/: @'BL'@ + | Page Point -- ^ /Valid for/: G + | PenColor Color -- ^ /Valid for/: C; /Default/: @X11Color 'Black'@ + | PenWidth Double -- ^ /Valid for/: CNE; /Default/: @1.0@; /Minimum/: @0.0@ + | Peripheries Int -- ^ /Valid for/: NC; /Default/: shape default (nodes), @1@ (clusters); /Minimum/: 0 + | Pin Bool -- ^ /Valid for/: N; /Default/: @'False'@; /Parsing Default/: 'True'; /Notes/: fdp, neato only + | Pos Pos -- ^ /Valid for/: EN + | QuadTree QuadType -- ^ /Valid for/: G; /Default/: @'NormalQT'@; /Parsing Default/: 'NormalQT'; /Notes/: sfdp only + | Quantum Double -- ^ /Valid for/: G; /Default/: @0.0@; /Minimum/: @0.0@ + | RankDir RankDir -- ^ /Valid for/: G; /Default/: @'TB'@; /Notes/: dot only + | RankSep Double -- ^ /Valid for/: G; /Default/: @0.5@ (dot), @1.0@ (twopi); /Minimum/: 0.02; /Notes/: twopi, dot only + | Rank RankType -- ^ /Valid for/: S; /Notes/: dot only + | Ratio Ratios -- ^ /Valid for/: G + | Rects Rect -- ^ /Valid for/: N; /Notes/: write only + | Regular Bool -- ^ /Valid for/: N; /Default/: @'False'@; /Parsing Default/: 'True' + | ReMinCross Bool -- ^ /Valid for/: G; /Default/: @'False'@; /Parsing Default/: 'True'; /Notes/: dot only + | RepulsiveForce Double -- ^ /Valid for/: G; /Default/: @1.0@; /Minimum/: @0.0@; /Notes/: sfdp only + | Root Root -- ^ /Valid for/: GN; /Default/: @'NodeName' \"\"@ (graphs), @'NotCentral'@ (nodes); /Parsing Default/: 'IsCentral'; /Notes/: circo, twopi only + | Rotate Int -- ^ /Valid for/: G; /Default/: @0@ + | SameHead String -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: dot only + | SameTail String -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: dot only + | SamplePoints Int -- ^ /Valid for/: N; /Default/: @8@ (output), @20@ (overlap and image maps) + | SearchSize Int -- ^ /Valid for/: G; /Default/: @30@; /Notes/: dot only + | Sep DPoint -- ^ /Valid for/: G; /Default/: @+4@; /Notes/: not dot + | ShapeFile String -- ^ /Valid for/: N; /Default/: @\"\"@ + | Shape Shape -- ^ /Valid for/: N; /Default/: @'Ellipse'@ + | ShowBoxes Int -- ^ /Valid for/: ENG; /Default/: @0@; /Minimum/: @0@; /Notes/: dot only + | Sides Int -- ^ /Valid for/: N; /Default/: @4@; /Minimum/: @0@ + | Size Point -- ^ /Valid for/: G + | Skew Double -- ^ /Valid for/: N; /Default/: @0.0@; /Minimum/: @-100.0@ + | Smoothing SmoothType -- ^ /Valid for/: G; /Default/: @'NoSmooth'@; /Notes/: sfdp only + | SortV Int -- ^ /Valid for/: GCN; /Default/: @0@; /Minimum/: @0@ + | Splines EdgeType -- ^ /Valid for/: G; /Parsing Default/: 'SplineEdges' + | Start StartType -- ^ /Valid for/: G; /Default/: @\"\"@; /Notes/: fdp, neato only + | StyleSheet String -- ^ /Valid for/: G; /Default/: @\"\"@; /Notes/: svg only + | Style [StyleItem] -- ^ /Valid for/: ENC + | TailURL URL -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: svg, map only + | TailClip Bool -- ^ /Valid for/: E; /Default/: @'True'@; /Parsing Default/: 'True' + | TailLabel Label -- ^ /Valid for/: E; /Default/: @\"\"@ + | TailPort PortPos -- ^ /Valid for/: E; /Default/: center + | TailTarget EscString -- ^ /Valid for/: E; /Default/: none; /Notes/: svg, map only + | TailTooltip EscString -- ^ /Valid for/: E; /Default/: @\"\"@; /Notes/: svg, cmap only + | Target EscString -- ^ /Valid for/: ENGC; /Default/: none; /Notes/: svg, map only + | Tooltip EscString -- ^ /Valid for/: NEC; /Default/: @\"\"@; /Notes/: svg, cmap only + | TrueColor Bool -- ^ /Valid for/: G; /Parsing Default/: 'True'; /Notes/: bitmap output only + | Vertices [Point] -- ^ /Valid for/: N; /Notes/: write only + | ViewPort ViewPort -- ^ /Valid for/: G; /Default/: none + | VoroMargin Double -- ^ /Valid for/: G; /Default/: @0.05@; /Minimum/: @0.0@; /Notes/: not dot + | Weight Double -- ^ /Valid for/: E; /Default/: @1.0@; /Minimum/: @0@ (dot), @1@ (neato,fdp,sfdp) + | Width Double -- ^ /Valid for/: N; /Default/: @0.75@; /Minimum/: @0.01@ + | Z Double -- ^ /Valid for/: N; /Default/: @0.0@; /Minimum/: @-MAXFLOAT@, @-1000@ + deriving (Eq, Ord, Show, Read) + +type Attributes = [Attribute] + +instance PrintDot Attribute where + unqtDot (Damping v) = printField "Damping" v + unqtDot (K v) = printField "K" v + unqtDot (URL v) = printField "URL" v + unqtDot (ArrowHead v) = printField "arrowhead" v + unqtDot (ArrowSize v) = printField "arrowsize" v + unqtDot (ArrowTail v) = printField "arrowtail" v + unqtDot (Aspect v) = printField "aspect" v + unqtDot (Bb v) = printField "bb" v + unqtDot (BgColor v) = printField "bgcolor" v + unqtDot (Center v) = printField "center" v + unqtDot (Charset v) = printField "charset" v + unqtDot (ClusterRank v) = printField "clusterrank" v + unqtDot (ColorScheme v) = printField "colorscheme" v + unqtDot (Color v) = printField "color" v + unqtDot (Comment v) = printField "comment" v + unqtDot (Compound v) = printField "compound" v + unqtDot (Concentrate v) = printField "concentrate" v + unqtDot (Constraint v) = printField "constraint" v + unqtDot (Decorate v) = printField "decorate" v + unqtDot (DefaultDist v) = printField "defaultdist" v + unqtDot (Dimen v) = printField "dimen" v + unqtDot (Dim v) = printField "dim" v + unqtDot (Dir v) = printField "dir" v + unqtDot (DirEdgeConstraints v) = printField "diredgeconstraints" v + unqtDot (Distortion v) = printField "distortion" v + unqtDot (DPI v) = printField "dpi" v + unqtDot (EdgeURL v) = printField "edgeURL" v + unqtDot (EdgeTarget v) = printField "edgetarget" v + unqtDot (EdgeTooltip v) = printField "edgetooltip" v + unqtDot (Epsilon v) = printField "epsilon" v + unqtDot (ESep v) = printField "esep" v + unqtDot (FillColor v) = printField "fillcolor" v + unqtDot (FixedSize v) = printField "fixedsize" v + unqtDot (FontColor v) = printField "fontcolor" v + unqtDot (FontName v) = printField "fontname" v + unqtDot (FontNames v) = printField "fontnames" v + unqtDot (FontPath v) = printField "fontpath" v + unqtDot (FontSize v) = printField "fontsize" v + unqtDot (Group v) = printField "group" v + unqtDot (HeadURL v) = printField "headURL" v + unqtDot (HeadClip v) = printField "headclip" v + unqtDot (HeadLabel v) = printField "headlabel" v + unqtDot (HeadPort v) = printField "headport" v + unqtDot (HeadTarget v) = printField "headtarget" v + unqtDot (HeadTooltip v) = printField "headtooltip" v + unqtDot (Height v) = printField "height" v + unqtDot (ID v) = printField "id" v + unqtDot (Image v) = printField "image" v + unqtDot (ImageScale v) = printField "imagescale" v + unqtDot (LabelURL v) = printField "labelURL" v + unqtDot (LabelAngle v) = printField "labelangle" v + unqtDot (LabelDistance v) = printField "labeldistance" v + unqtDot (LabelFloat v) = printField "labelfloat" v + unqtDot (LabelFontColor v) = printField "labelfontcolor" v + unqtDot (LabelFontName v) = printField "labelfontname" v + unqtDot (LabelFontSize v) = printField "labelfontsize" v + unqtDot (LabelJust v) = printField "labeljust" v + unqtDot (LabelLoc v) = printField "labelloc" v + unqtDot (LabelTarget v) = printField "labeltarget" v + unqtDot (LabelTooltip v) = printField "labeltooltip" v + unqtDot (Label v) = printField "label" v + unqtDot (Landscape v) = printField "landscape" v + unqtDot (LayerSep v) = printField "layersep" v + unqtDot (Layers v) = printField "layers" v + unqtDot (Layer v) = printField "layer" v + unqtDot (Layout v) = printField "layout" v + unqtDot (Len v) = printField "len" v + unqtDot (LevelsGap v) = printField "levelsgap" v + unqtDot (Levels v) = printField "levels" v + unqtDot (LHead v) = printField "lhead" v + unqtDot (LPos v) = printField "lp" v + unqtDot (LTail v) = printField "ltail" v + unqtDot (Margin v) = printField "margin" v + unqtDot (MaxIter v) = printField "maxiter" v + unqtDot (MCLimit v) = printField "mclimit" v + unqtDot (MinDist v) = printField "mindist" v + unqtDot (MinLen v) = printField "minlen" v + unqtDot (Model v) = printField "model" v + unqtDot (Mode v) = printField "mode" v + unqtDot (Mosek v) = printField "mosek" v + unqtDot (NodeSep v) = printField "nodesep" v + unqtDot (NoJustify v) = printField "nojustify" v + unqtDot (Normalize v) = printField "normalize" v + unqtDot (Nslimit1 v) = printField "nslimit1" v + unqtDot (Nslimit v) = printField "nslimit" v + unqtDot (Ordering v) = printField "ordering" v + unqtDot (Orientation v) = printField "orientation" v + unqtDot (OutputOrder v) = printField "outputorder" v + unqtDot (OverlapScaling v) = printField "overlap_scaling" v + unqtDot (Overlap v) = printField "overlap" v + unqtDot (PackMode v) = printField "packmode" v + unqtDot (Pack v) = printField "pack" v + unqtDot (Pad v) = printField "pad" v + unqtDot (PageDir v) = printField "pagedir" v + unqtDot (Page v) = printField "page" v + unqtDot (PenColor v) = printField "pencolor" v + unqtDot (PenWidth v) = printField "penwidth" v + unqtDot (Peripheries v) = printField "peripheries" v + unqtDot (Pin v) = printField "pin" v + unqtDot (Pos v) = printField "pos" v + unqtDot (QuadTree v) = printField "quadtree" v + unqtDot (Quantum v) = printField "quantum" v + unqtDot (RankDir v) = printField "rankdir" v + unqtDot (RankSep v) = printField "ranksep" v + unqtDot (Rank v) = printField "rank" v + unqtDot (Ratio v) = printField "ratio" v + unqtDot (Rects v) = printField "rects" v + unqtDot (Regular v) = printField "regular" v + unqtDot (ReMinCross v) = printField "remincross" v + unqtDot (RepulsiveForce v) = printField "repulsiveforce" v + unqtDot (Root v) = printField "root" v + unqtDot (Rotate v) = printField "rotate" v + unqtDot (SameHead v) = printField "samehead" v + unqtDot (SameTail v) = printField "sametail" v + unqtDot (SamplePoints v) = printField "samplepoints" v + unqtDot (SearchSize v) = printField "searchsize" v + unqtDot (Sep v) = printField "sep" v + unqtDot (ShapeFile v) = printField "shapefile" v + unqtDot (Shape v) = printField "shape" v + unqtDot (ShowBoxes v) = printField "showboxes" v + unqtDot (Sides v) = printField "sides" v + unqtDot (Size v) = printField "size" v + unqtDot (Skew v) = printField "skew" v + unqtDot (Smoothing v) = printField "smoothing" v + unqtDot (SortV v) = printField "sortv" v + unqtDot (Splines v) = printField "splines" v + unqtDot (Start v) = printField "start" v + unqtDot (StyleSheet v) = printField "stylesheet" v + unqtDot (Style v) = printField "style" v + unqtDot (TailURL v) = printField "tailURL" v + unqtDot (TailClip v) = printField "tailclip" v + unqtDot (TailLabel v) = printField "taillabel" v + unqtDot (TailPort v) = printField "tailport" v + unqtDot (TailTarget v) = printField "tailtarget" v + unqtDot (TailTooltip v) = printField "tailtooltip" v + unqtDot (Target v) = printField "target" v + unqtDot (Tooltip v) = printField "tooltip" v + unqtDot (TrueColor v) = printField "truecolor" v + unqtDot (Vertices v) = printField "vertices" v + unqtDot (ViewPort v) = printField "viewport" v + unqtDot (VoroMargin v) = printField "voro_margin" v + unqtDot (Weight v) = printField "weight" v + unqtDot (Width v) = printField "width" v + unqtDot (Z v) = printField "z" v + + listToDot = unqtListToDot + +instance ParseDot Attribute where + parseUnqt = oneOf [ liftM Damping $ parseField "Damping" + , liftM K $ parseField "K" + , liftM URL $ parseFields ["URL", "href"] + , liftM ArrowHead $ parseField "arrowhead" + , liftM ArrowSize $ parseField "arrowsize" + , liftM ArrowTail $ parseField "arrowtail" + , liftM Aspect $ parseField "aspect" + , liftM Bb $ parseField "bb" + , liftM BgColor $ parseField "bgcolor" + , liftM Center $ parseFieldBool "center" + , liftM Charset $ parseField "charset" + , liftM ClusterRank $ parseField "clusterrank" + , liftM ColorScheme $ parseField "colorscheme" + , liftM Color $ parseField "color" + , liftM Comment $ parseField "comment" + , liftM Compound $ parseFieldBool "compound" + , liftM Concentrate $ parseFieldBool "concentrate" + , liftM Constraint $ parseFieldBool "constraint" + , liftM Decorate $ parseFieldBool "decorate" + , liftM DefaultDist $ parseField "defaultdist" + , liftM Dimen $ parseField "dimen" + , liftM Dim $ parseField "dim" + , liftM Dir $ parseField "dir" + , liftM DirEdgeConstraints $ parseFieldDef EdgeConstraints "diredgeconstraints" + , liftM Distortion $ parseField "distortion" + , liftM DPI $ parseFields ["dpi", "resolution"] + , liftM EdgeURL $ parseFields ["edgeURL", "edgehref"] + , liftM EdgeTarget $ parseField "edgetarget" + , liftM EdgeTooltip $ parseField "edgetooltip" + , liftM Epsilon $ parseField "epsilon" + , liftM ESep $ parseField "esep" + , liftM FillColor $ parseField "fillcolor" + , liftM FixedSize $ parseFieldBool "fixedsize" + , liftM FontColor $ parseField "fontcolor" + , liftM FontName $ parseField "fontname" + , liftM FontNames $ parseField "fontnames" + , liftM FontPath $ parseField "fontpath" + , liftM FontSize $ parseField "fontsize" + , liftM Group $ parseField "group" + , liftM HeadURL $ parseFields ["headURL", "headhref"] + , liftM HeadClip $ parseFieldBool "headclip" + , liftM HeadLabel $ parseField "headlabel" + , liftM HeadPort $ parseField "headport" + , liftM HeadTarget $ parseField "headtarget" + , liftM HeadTooltip $ parseField "headtooltip" + , liftM Height $ parseField "height" + , liftM ID $ parseField "id" + , liftM Image $ parseField "image" + , liftM ImageScale $ parseFieldDef UniformScale "imagescale" + , liftM LabelURL $ parseFields ["labelURL", "labelhref"] + , liftM LabelAngle $ parseField "labelangle" + , liftM LabelDistance $ parseField "labeldistance" + , liftM LabelFloat $ parseFieldBool "labelfloat" + , liftM LabelFontColor $ parseField "labelfontcolor" + , liftM LabelFontName $ parseField "labelfontname" + , liftM LabelFontSize $ parseField "labelfontsize" + , liftM LabelJust $ parseField "labeljust" + , liftM LabelLoc $ parseField "labelloc" + , liftM LabelTarget $ parseField "labeltarget" + , liftM LabelTooltip $ parseField "labeltooltip" + , liftM Label $ parseField "label" + , liftM Landscape $ parseFieldBool "landscape" + , liftM LayerSep $ parseField "layersep" + , liftM Layers $ parseField "layers" + , liftM Layer $ parseField "layer" + , liftM Layout $ parseField "layout" + , liftM Len $ parseField "len" + , liftM LevelsGap $ parseField "levelsgap" + , liftM Levels $ parseField "levels" + , liftM LHead $ parseField "lhead" + , liftM LPos $ parseField "lp" + , liftM LTail $ parseField "ltail" + , liftM Margin $ parseField "margin" + , liftM MaxIter $ parseField "maxiter" + , liftM MCLimit $ parseField "mclimit" + , liftM MinDist $ parseField "mindist" + , liftM MinLen $ parseField "minlen" + , liftM Model $ parseField "model" + , liftM Mode $ parseField "mode" + , liftM Mosek $ parseFieldBool "mosek" + , liftM NodeSep $ parseField "nodesep" + , liftM NoJustify $ parseFieldBool "nojustify" + , liftM Normalize $ parseFieldBool "normalize" + , liftM Nslimit1 $ parseField "nslimit1" + , liftM Nslimit $ parseField "nslimit" + , liftM Ordering $ parseField "ordering" + , liftM Orientation $ parseField "orientation" + , liftM OutputOrder $ parseField "outputorder" + , liftM OverlapScaling $ parseField "overlap_scaling" + , liftM Overlap $ parseFieldDef KeepOverlaps "overlap" + , liftM PackMode $ parseField "packmode" + , liftM Pack $ parseFieldDef DoPack "pack" + , liftM Pad $ parseField "pad" + , liftM PageDir $ parseField "pagedir" + , liftM Page $ parseField "page" + , liftM PenColor $ parseField "pencolor" + , liftM PenWidth $ parseField "penwidth" + , liftM Peripheries $ parseField "peripheries" + , liftM Pin $ parseFieldBool "pin" + , liftM Pos $ parseField "pos" + , liftM QuadTree $ parseFieldDef NormalQT "quadtree" + , liftM Quantum $ parseField "quantum" + , liftM RankDir $ parseField "rankdir" + , liftM RankSep $ parseField "ranksep" + , liftM Rank $ parseField "rank" + , liftM Ratio $ parseField "ratio" + , liftM Rects $ parseField "rects" + , liftM Regular $ parseFieldBool "regular" + , liftM ReMinCross $ parseFieldBool "remincross" + , liftM RepulsiveForce $ parseField "repulsiveforce" + , liftM Root $ parseFieldDef IsCentral "root" + , liftM Rotate $ parseField "rotate" + , liftM SameHead $ parseField "samehead" + , liftM SameTail $ parseField "sametail" + , liftM SamplePoints $ parseField "samplepoints" + , liftM SearchSize $ parseField "searchsize" + , liftM Sep $ parseField "sep" + , liftM ShapeFile $ parseField "shapefile" + , liftM Shape $ parseField "shape" + , liftM ShowBoxes $ parseField "showboxes" + , liftM Sides $ parseField "sides" + , liftM Size $ parseField "size" + , liftM Skew $ parseField "skew" + , liftM Smoothing $ parseField "smoothing" + , liftM SortV $ parseField "sortv" + , liftM Splines $ parseFieldDef SplineEdges "splines" + , liftM Start $ parseField "start" + , liftM StyleSheet $ parseField "stylesheet" + , liftM Style $ parseField "style" + , liftM TailURL $ parseFields ["tailURL", "tailhref"] + , liftM TailClip $ parseFieldBool "tailclip" + , liftM TailLabel $ parseField "taillabel" + , liftM TailPort $ parseField "tailport" + , liftM TailTarget $ parseField "tailtarget" + , liftM TailTooltip $ parseField "tailtooltip" + , liftM Target $ parseField "target" + , liftM Tooltip $ parseField "tooltip" + , liftM TrueColor $ parseFieldBool "truecolor" + , liftM Vertices $ parseField "vertices" + , liftM ViewPort $ parseField "viewport" + , liftM VoroMargin $ parseField "voro_margin" + , liftM Weight $ parseField "weight" + , liftM Width $ parseField "width" + , liftM Z $ parseField "z" + ] + + parse = parseUnqt + + parseList = parseUnqtList + +-- | Determine if this Attribute is valid for use with Graphs. +usedByGraphs :: Attribute -> Bool +usedByGraphs Damping{} = True +usedByGraphs K{} = True +usedByGraphs URL{} = True +usedByGraphs Aspect{} = True +usedByGraphs Bb{} = True +usedByGraphs BgColor{} = True +usedByGraphs Center{} = True +usedByGraphs Charset{} = True +usedByGraphs ClusterRank{} = True +usedByGraphs ColorScheme{} = True +usedByGraphs Comment{} = True +usedByGraphs Compound{} = True +usedByGraphs Concentrate{} = True +usedByGraphs DefaultDist{} = True +usedByGraphs Dimen{} = True +usedByGraphs Dim{} = True +usedByGraphs DirEdgeConstraints{} = True +usedByGraphs DPI{} = True +usedByGraphs Epsilon{} = True +usedByGraphs ESep{} = True +usedByGraphs FontColor{} = True +usedByGraphs FontName{} = True +usedByGraphs FontNames{} = True +usedByGraphs FontPath{} = True +usedByGraphs FontSize{} = True +usedByGraphs ID{} = True +usedByGraphs LabelJust{} = True +usedByGraphs LabelLoc{} = True +usedByGraphs Label{} = True +usedByGraphs Landscape{} = True +usedByGraphs LayerSep{} = True +usedByGraphs Layers{} = True +usedByGraphs Layout{} = True +usedByGraphs LevelsGap{} = True +usedByGraphs Levels{} = True +usedByGraphs LPos{} = True +usedByGraphs Margin{} = True +usedByGraphs MaxIter{} = True +usedByGraphs MCLimit{} = True +usedByGraphs MinDist{} = True +usedByGraphs Model{} = True +usedByGraphs Mode{} = True +usedByGraphs Mosek{} = True +usedByGraphs NodeSep{} = True +usedByGraphs NoJustify{} = True +usedByGraphs Normalize{} = True +usedByGraphs Nslimit1{} = True +usedByGraphs Nslimit{} = True +usedByGraphs Ordering{} = True +usedByGraphs OutputOrder{} = True +usedByGraphs OverlapScaling{} = True +usedByGraphs Overlap{} = True +usedByGraphs PackMode{} = True +usedByGraphs Pack{} = True +usedByGraphs Pad{} = True +usedByGraphs PageDir{} = True +usedByGraphs Page{} = True +usedByGraphs QuadTree{} = True +usedByGraphs Quantum{} = True +usedByGraphs RankDir{} = True +usedByGraphs RankSep{} = True +usedByGraphs Ratio{} = True +usedByGraphs ReMinCross{} = True +usedByGraphs RepulsiveForce{} = True +usedByGraphs Root{} = True +usedByGraphs Rotate{} = True +usedByGraphs SearchSize{} = True +usedByGraphs Sep{} = True +usedByGraphs ShowBoxes{} = True +usedByGraphs Size{} = True +usedByGraphs Smoothing{} = True +usedByGraphs SortV{} = True +usedByGraphs Splines{} = True +usedByGraphs Start{} = True +usedByGraphs StyleSheet{} = True +usedByGraphs Target{} = True +usedByGraphs TrueColor{} = True +usedByGraphs ViewPort{} = True +usedByGraphs VoroMargin{} = True +usedByGraphs _ = False + +-- | Determine if this Attribute is valid for use with Clusters. +usedByClusters :: Attribute -> Bool +usedByClusters K{} = True +usedByClusters URL{} = True +usedByClusters BgColor{} = True +usedByClusters ColorScheme{} = True +usedByClusters Color{} = True +usedByClusters FillColor{} = True +usedByClusters FontColor{} = True +usedByClusters FontName{} = True +usedByClusters FontSize{} = True +usedByClusters LabelJust{} = True +usedByClusters LabelLoc{} = True +usedByClusters Label{} = True +usedByClusters LPos{} = True +usedByClusters NoJustify{} = True +usedByClusters PenColor{} = True +usedByClusters PenWidth{} = True +usedByClusters Peripheries{} = True +usedByClusters Rank{} = True +usedByClusters SortV{} = True +usedByClusters Style{} = True +usedByClusters Target{} = True +usedByClusters Tooltip{} = True +usedByClusters _ = False + +-- | Determine if this Attribute is valid for use with SubGraphs. +usedBySubGraphs :: Attribute -> Bool +usedBySubGraphs Rank{} = True +usedBySubGraphs _ = False + +-- | Determine if this Attribute is valid for use with Nodes. +usedByNodes :: Attribute -> Bool +usedByNodes URL{} = True +usedByNodes ColorScheme{} = True +usedByNodes Color{} = True +usedByNodes Comment{} = True +usedByNodes Distortion{} = True +usedByNodes FillColor{} = True +usedByNodes FixedSize{} = True +usedByNodes FontColor{} = True +usedByNodes FontName{} = True +usedByNodes FontSize{} = True +usedByNodes Group{} = True +usedByNodes Height{} = True +usedByNodes ID{} = True +usedByNodes Image{} = True +usedByNodes ImageScale{} = True +usedByNodes LabelLoc{} = True +usedByNodes Label{} = True +usedByNodes Layer{} = True +usedByNodes Margin{} = True +usedByNodes NoJustify{} = True +usedByNodes Orientation{} = True +usedByNodes PenWidth{} = True +usedByNodes Peripheries{} = True +usedByNodes Pin{} = True +usedByNodes Pos{} = True +usedByNodes Rects{} = True +usedByNodes Regular{} = True +usedByNodes Root{} = True +usedByNodes SamplePoints{} = True +usedByNodes ShapeFile{} = True +usedByNodes Shape{} = True +usedByNodes ShowBoxes{} = True +usedByNodes Sides{} = True +usedByNodes Skew{} = True +usedByNodes SortV{} = True +usedByNodes Style{} = True +usedByNodes Target{} = True +usedByNodes Tooltip{} = True +usedByNodes Vertices{} = True +usedByNodes Width{} = True +usedByNodes Z{} = True +usedByNodes _ = False + +-- | Determine if this Attribute is valid for use with Edges. +usedByEdges :: Attribute -> Bool +usedByEdges URL{} = True +usedByEdges ArrowHead{} = True +usedByEdges ArrowSize{} = True +usedByEdges ArrowTail{} = True +usedByEdges ColorScheme{} = True +usedByEdges Color{} = True +usedByEdges Comment{} = True +usedByEdges Constraint{} = True +usedByEdges Decorate{} = True +usedByEdges Dir{} = True +usedByEdges EdgeURL{} = True +usedByEdges EdgeTarget{} = True +usedByEdges EdgeTooltip{} = True +usedByEdges FontColor{} = True +usedByEdges FontName{} = True +usedByEdges FontSize{} = True +usedByEdges HeadURL{} = True +usedByEdges HeadClip{} = True +usedByEdges HeadLabel{} = True +usedByEdges HeadPort{} = True +usedByEdges HeadTarget{} = True +usedByEdges HeadTooltip{} = True +usedByEdges ID{} = True +usedByEdges LabelURL{} = True +usedByEdges LabelAngle{} = True +usedByEdges LabelDistance{} = True +usedByEdges LabelFloat{} = True +usedByEdges LabelFontColor{} = True +usedByEdges LabelFontName{} = True +usedByEdges LabelFontSize{} = True +usedByEdges LabelTarget{} = True +usedByEdges LabelTooltip{} = True +usedByEdges Label{} = True +usedByEdges Layer{} = True +usedByEdges Len{} = True +usedByEdges LHead{} = True +usedByEdges LPos{} = True +usedByEdges LTail{} = True +usedByEdges MinLen{} = True +usedByEdges NoJustify{} = True +usedByEdges PenWidth{} = True +usedByEdges Pos{} = True +usedByEdges SameHead{} = True +usedByEdges SameTail{} = True +usedByEdges ShowBoxes{} = True +usedByEdges Style{} = True +usedByEdges TailURL{} = True +usedByEdges TailClip{} = True +usedByEdges TailLabel{} = True +usedByEdges TailPort{} = True +usedByEdges TailTarget{} = True +usedByEdges TailTooltip{} = True +usedByEdges Target{} = True +usedByEdges Tooltip{} = True +usedByEdges Weight{} = True +usedByEdges _ = False + +{- Delete to here -} +-- ----------------------------------------------------------------------------- + +{- | + + Some 'Attribute's (mainly label-like ones) take a 'String' argument + that allows for extra escape codes. This library doesn't do any + extra checks or special parsing for these escape codes, but usage + of 'EscString' rather than 'String' indicates that the Graphviz + tools will recognise these extra escape codes for these + 'Attribute's. + + The extra escape codes include (note that these are all 'String's): + + [@\\N@] Replace with the name of the node (for Node 'Attribute's). + + [@\\G@] Replace with the name of the graph (for Node 'Attribute's) + or the name of the graph or cluster, whichever is + applicable (for Graph, Cluster and Edge 'Attribute's). + + [@\\E@] Replace with the name of the edge, formed by the two + adjoining nodes and the edge type (for Edge 'Attribute's). + + [@\\T@] Replace with the name of the tail node (for Edge + 'Attribute's). + + [@\\H@] Replace with the name of the head node (for Edge + 'Attribute's). + + [@\\L@] Replace with the object's label (for all 'Attribute's). + + Also, if the 'Attribute' in question is 'Label', 'HeadLabel' or + 'TailLabel', then @\\n@, @\\l@ and @\\r@ split the label into lines + centered, left-justified and right-justified respectively. + + -} +type EscString = String + +-- ----------------------------------------------------------------------------- + +-- | No checks are placed on the content of a 'URL' value; however, +-- you should ensure that it does not contain any \'@>@\' or \'@<@\' +-- characters; Graphviz might care about escaping other characters +-- properly, but for the purposes of this library the presence of +-- these characters will make it harder to parse URLs. +newtype URL = UStr { urlString :: EscString } + deriving (Eq, Ord, Show, Read) + +instance PrintDot URL where + unqtDot = wrap (char '<') (char '>') + -- Explicitly use text here... no quotes! + . text . urlString + +instance ParseDot URL where + parseUnqt = liftM UStr + $ bracket (character open) + (character close) + (many1 $ satisfy ((/=) close)) + where + open = '<' + close = '>' + + -- No quotes + parse = parseUnqt + +-- ----------------------------------------------------------------------------- + +-- | /Dot/ has a basic grammar of arrow shapes which allows usage of +-- up to 1,544,761 different shapes from 9 different basic +-- 'ArrowShape's. Note that whilst an explicit list is used in the +-- definition of 'ArrowType', there must be at least one tuple and a +-- maximum of 4 (since that is what is required by Dot). For more +-- information, see: +-- +-- The 19 basic arrows shown on the overall attributes page have +-- been defined below as a convenience. Parsing of the 5 +-- backward-compatible special cases is also supported. +newtype ArrowType = AType [(ArrowModifier, ArrowShape)] + deriving (Eq, Ord, Show, Read) + +box, crow, diamond, dotArrow, inv, noArrow, normal, tee, vee :: ArrowType +oDot, invDot, invODot, oBox, oDiamond :: ArrowType +eDiamond, openArr, halfOpen, emptyArr, invEmpty :: ArrowType + +normal = AType [(noMods, Normal)] +inv = AType [(noMods, Inv)] +dotArrow = AType [(noMods, DotArrow)] +invDot = AType [ (noMods, Inv) + , (noMods, DotArrow)] +oDot = AType [(ArrMod OpenArrow BothSides, DotArrow)] +invODot = AType [ (noMods, Inv) + , (openMod, DotArrow)] +noArrow = AType [(noMods, NoArrow)] +tee = AType [(noMods, Tee)] +emptyArr = AType [(openMod, Normal)] +invEmpty = AType [ (noMods, Inv) + , (openMod, Normal)] +diamond = AType [(noMods, Diamond)] +oDiamond = AType [(openMod, Diamond)] +eDiamond = oDiamond +crow = AType [(noMods, Crow)] +box = AType [(noMods, Box)] +oBox = AType [(openMod, Box)] +openArr = vee +halfOpen = AType [(ArrMod FilledArrow LeftSide, Vee)] +vee = AType [(noMods, Vee)] + +instance PrintDot ArrowType where + unqtDot (AType mas) = hcat $ map appMod mas + where + appMod (m, a) = unqtDot m <> unqtDot a + +instance ParseDot ArrowType where + parseUnqt = do mas <- many1 $ do m <- parseUnqt + a <- parseUnqt + return (m,a) + return $ AType mas + `onFail` + specialArrowParse + +specialArrowParse :: Parse ArrowType +specialArrowParse = oneOf [ stringRep eDiamond "ediamond" + , stringRep openArr "open" + , stringRep halfOpen "halfopen" + , stringRep emptyArr "empty" + , stringRep invEmpty "invempty" + ] + +data ArrowShape = Box + | Crow + | Diamond + | DotArrow + | Inv + | NoArrow + | Normal + | Tee + | Vee + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot ArrowShape where + unqtDot Box = unqtDot "box" + unqtDot Crow = unqtDot "crow" + unqtDot Diamond = unqtDot "diamond" + unqtDot DotArrow = unqtDot "dot" + unqtDot Inv = unqtDot "inv" + unqtDot NoArrow = unqtDot "none" + unqtDot Normal = unqtDot "normal" + unqtDot Tee = unqtDot "tee" + unqtDot Vee = unqtDot "vee" + +instance ParseDot ArrowShape where + parseUnqt = oneOf [ stringRep Box "box" + , stringRep Crow "crow" + , stringRep Diamond "diamond" + , stringRep DotArrow "dot" + , stringRep Inv "inv" + , stringRep NoArrow "none" + , stringRep Normal "normal" + , stringRep Tee "tee" + , stringRep Vee "vee" + ] + +-- | What modifications to apply to an 'ArrowShape'. +data ArrowModifier = ArrMod { arrowFill :: ArrowFill + , arrowSide :: ArrowSide + } + deriving (Eq, Ord, Show, Read) + +-- | Apply no modifications to an 'ArrowShape'. +noMods :: ArrowModifier +noMods = ArrMod FilledArrow BothSides + +-- | 'OpenArrow' and 'BothSides' +openMod :: ArrowModifier +openMod = ArrMod OpenArrow BothSides + +instance PrintDot ArrowModifier where + unqtDot (ArrMod f s) = unqtDot f <> unqtDot s + +instance ParseDot ArrowModifier where + parseUnqt = do f <- parseUnqt + s <- parseUnqt + return $ ArrMod f s + +data ArrowFill = OpenArrow + | FilledArrow + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot ArrowFill where + unqtDot OpenArrow = char 'o' + unqtDot FilledArrow = empty + +instance ParseDot ArrowFill where + parseUnqt = liftM (bool FilledArrow OpenArrow . isJust) + $ optional (character 'o') + + -- Not used individually + parse = parseUnqt + +-- | Represents which side (when looking towards the node the arrow is +-- pointing to) is drawn. +data ArrowSide = LeftSide + | RightSide + | BothSides + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot ArrowSide where + unqtDot LeftSide = char 'l' + unqtDot RightSide = char 'r' + unqtDot BothSides = empty + +instance ParseDot ArrowSide where + parseUnqt = liftM getSideType + $ optional (oneOf $ map character ['l', 'r']) + where + getSideType = maybe BothSides + (bool RightSide LeftSide . (==) 'l') + + -- Not used individually + parse = parseUnqt + +-- ----------------------------------------------------------------------------- + +data AspectType = RatioOnly Double + | RatioPassCount Double Int + deriving (Eq, Ord, Show, Read) + +instance PrintDot AspectType where + unqtDot (RatioOnly r) = unqtDot r + unqtDot (RatioPassCount r p) = commaDel r p + + toDot at@RatioOnly{} = unqtDot at + toDot at@RatioPassCount{} = doubleQuotes $ unqtDot at + +instance ParseDot AspectType where + parseUnqt = liftM (uncurry RatioPassCount) commaSepUnqt + `onFail` + liftM RatioOnly parseUnqt + + + parse = quotedParse (liftM (uncurry RatioPassCount) commaSepUnqt) + `onFail` + liftM RatioOnly parse + +-- ----------------------------------------------------------------------------- + +data Rect = Rect Point Point + deriving (Eq, Ord, Show, Read) + +instance PrintDot Rect where + unqtDot (Rect p1 p2) = commaDel p1 p2 + + toDot = doubleQuotes . unqtDot + +instance ParseDot Rect where + parseUnqt = liftM (uncurry Rect) commaSepUnqt + + parse = quotedParse parseUnqt + +-- ----------------------------------------------------------------------------- + +data ClusterMode = Local + | Global + | NoCluster + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot ClusterMode where + unqtDot Local = unqtDot "local" + unqtDot Global = unqtDot "global" + unqtDot NoCluster = unqtDot "none" + + + +instance ParseDot ClusterMode where + parseUnqt = oneOf [ stringRep Local "local" + , stringRep Global "global" + , stringRep NoCluster "none" + ] + +-- ----------------------------------------------------------------------------- + +data DirType = Forward | Back | Both | NoDir + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot DirType where + unqtDot Forward = unqtDot "forward" + unqtDot Back = unqtDot "back" + unqtDot Both = unqtDot "both" + unqtDot NoDir = unqtDot "none" + +instance ParseDot DirType where + parseUnqt = oneOf [ stringRep Forward "forward" + , stringRep Back "back" + , stringRep Both "both" + , stringRep NoDir "none" + ] + +-- ----------------------------------------------------------------------------- + +-- | Only when @mode == 'IpSep'@. +data DEConstraints = EdgeConstraints + | NoConstraints + | HierConstraints + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot DEConstraints where + unqtDot EdgeConstraints = unqtDot True + unqtDot NoConstraints = unqtDot False + unqtDot HierConstraints = text "hier" + +instance ParseDot DEConstraints where + parseUnqt = liftM (bool NoConstraints EdgeConstraints) parse + `onFail` + stringRep HierConstraints "hier" + +-- ----------------------------------------------------------------------------- + +-- | Either a 'Double' or a 'Point'. +data DPoint = DVal Double + | PVal Point + deriving (Eq, Ord, Show, Read) + +instance PrintDot DPoint where + unqtDot (DVal d) = unqtDot d + unqtDot (PVal p) = unqtDot p + + toDot (DVal d) = toDot d + toDot (PVal p) = toDot p + +instance ParseDot DPoint where + parseUnqt = liftM PVal parseUnqt + `onFail` + liftM DVal parseUnqt + + parse = liftM PVal parse + `onFail` + liftM DVal parse + +-- ----------------------------------------------------------------------------- + +data ModeType = Major + | KK + | Hier + | IpSep + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot ModeType where + unqtDot Major = text "major" + unqtDot KK = text "KK" + unqtDot Hier = text "hier" + unqtDot IpSep = text "ipsep" + +instance ParseDot ModeType where + parseUnqt = oneOf [ stringRep Major "major" + , stringRep KK "KK" + , stringRep Hier "hier" + , stringRep IpSep "ipsep" + ] + +-- ----------------------------------------------------------------------------- + +data Model = ShortPath + | SubSet + | Circuit + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot Model where + unqtDot ShortPath = text "shortpath" + unqtDot SubSet = text "subset" + unqtDot Circuit = text "circuit" + +instance ParseDot Model where + parseUnqt = oneOf [ stringRep ShortPath "shortpath" + , stringRep SubSet "subset" + , stringRep Circuit "circuit" + ] + +-- ----------------------------------------------------------------------------- + +data Label = StrLabel EscString + | URLLabel URL + deriving (Eq, Ord, Show, Read) + +instance PrintDot Label where + unqtDot (StrLabel s) = unqtDot s + unqtDot (URLLabel u) = unqtDot u + + toDot (StrLabel s) = toDot s + toDot (URLLabel u) = toDot u + +instance ParseDot Label where + parseUnqt = liftM StrLabel parseUnqt + `onFail` + liftM URLLabel parseUnqt + + parse = liftM StrLabel parse + `onFail` + liftM URLLabel parse + +-- ----------------------------------------------------------------------------- + +data Point = Point Int Int + | PointD Double Double + deriving (Eq, Ord, Show, Read) + +instance PrintDot Point where + unqtDot (Point x y) = commaDel x y + unqtDot (PointD x y) = commaDel x y + + toDot = doubleQuotes . unqtDot + + unqtListToDot = hsep . map unqtDot + + listToDot = doubleQuotes . unqtListToDot + +instance ParseDot Point where + -- Need to take into account the situation where first value is an + -- integer, second a double: if Point parsing first, then it won't + -- parse the second number properly; but if PointD first then it + -- will treat Int/Int as Double/Double. + parseUnqt = intDblPoint + `onFail` + liftM (uncurry Point) commaSepUnqt + `onFail` + liftM (uncurry PointD) commaSepUnqt + where + intDblPoint = liftM (uncurry PointD . first fI) + $ commaSep' parseUnqt parseStrictFloat + fI :: Int -> Double + fI = fromIntegral + + parse = quotedParse parseUnqt + + parseUnqtList = sepBy1 parseUnqt whitespace + +-- ----------------------------------------------------------------------------- + +data Overlap = KeepOverlaps + | RemoveOverlaps + | ScaleOverlaps + | ScaleXYOverlaps + | PrismOverlap (Maybe Int) -- ^ Only when sfdp is available, 'Int' is non-negative + | CompressOverlap + | VpscOverlap + | IpsepOverlap -- ^ Only when @mode == 'IpSep'@ + deriving (Eq, Ord, Show, Read) + +instance PrintDot Overlap where + unqtDot KeepOverlaps = unqtDot True + unqtDot RemoveOverlaps = unqtDot False + unqtDot ScaleOverlaps = text "scale" + unqtDot ScaleXYOverlaps = text "scalexy" + unqtDot (PrismOverlap i) = maybe id (flip (<>) . unqtDot) i $ text "prism" + unqtDot CompressOverlap = text "compress" + unqtDot VpscOverlap = text "vpsc" + unqtDot IpsepOverlap = text "ipsep" + +instance ParseDot Overlap where + parseUnqt = oneOf [ stringRep KeepOverlaps "true" + , stringRep RemoveOverlaps "false" + , stringRep ScaleXYOverlaps "scalexy" + , stringRep ScaleOverlaps "scale" + , string "prism" >> liftM PrismOverlap (optional parse) + , stringRep CompressOverlap "compress" + , stringRep VpscOverlap "vpsc" + , stringRep IpsepOverlap "ipsep" + ] + +-- ----------------------------------------------------------------------------- + +data LayerRange = LRID LayerID + | LRS LayerID String LayerID + deriving (Eq, Ord, Show, Read) + +instance PrintDot LayerRange where + unqtDot (LRID lid) = unqtDot lid + unqtDot (LRS id1 s id2) = unqtDot id1 <> unqtDot s <> unqtDot id2 + + toDot (LRID lid) = toDot lid + toDot lrs = doubleQuotes $ unqtDot lrs + +instance ParseDot LayerRange where + parseUnqt = do id1 <- parseUnqt + s <- parseLayerSep + id2 <- parseUnqt + return $ LRS id1 s id2 + `onFail` + liftM LRID parseUnqt + + + parse = quotedParse ( do id1 <- parseUnqt + s <- parseLayerSep + id2 <- parseUnqt + return $ LRS id1 s id2 + ) + `onFail` + liftM LRID parse + +parseLayerSep :: Parse String +parseLayerSep = many1 . oneOf + $ map character defLayerSep + +defLayerSep :: [Char] +defLayerSep = [' ', ':', '\t'] + +parseLayerName :: Parse String +parseLayerName = many1 . orQuote + $ satisfy (liftM2 (&&) notLayerSep ((/=) quoteChar)) + +parseLayerName' :: Parse String +parseLayerName' = stringBlock + `onFail` + quotedParse parseLayerName + +notLayerSep :: Char -> Bool +notLayerSep = flip notElem defLayerSep + +-- | You should not have any quote characters for the 'LRName' option, +-- as it won't be parseable. +data LayerID = AllLayers + | LRInt Int + | LRName String + deriving (Eq, Ord, Show, Read) + +instance PrintDot LayerID where + unqtDot AllLayers = text "all" + unqtDot (LRInt n) = unqtDot n + unqtDot (LRName nm) = unqtDot nm + + toDot (LRName nm) = toDot nm + -- Other two don't need quotes + toDot li = unqtDot li + +instance ParseDot LayerID where + parseUnqt = liftM checkLayerName parseLayerName -- tests for Int and All + + parse = oneOf [ liftM checkLayerName parseLayerName' + , liftM LRInt parse -- Mainly for unquoted case. + ] + +checkLayerName :: String -> LayerID +checkLayerName str = maybe checkAll LRInt $ stringToInt str + where + checkAll = if map toLower str == "all" + then AllLayers + else LRName str + +-- | The list represent (Separator, Name). You should not have any +-- quote characters for any of the 'String's, since there are +-- parsing problems with them. +data LayerList = LL String [(String, String)] + deriving (Eq, Ord, Show, Read) + +instance PrintDot LayerList where + unqtDot (LL l1 ols) = unqtDot l1 <> hcat (map subLL ols) + where + subLL (s, l) = unqtDot s <> unqtDot l + + toDot (LL l1 []) = toDot l1 + -- Might not need quotes, but probably will. + toDot ll = doubleQuotes $ unqtDot ll + +instance ParseDot LayerList where + parseUnqt = do l1 <- parseLayerName + ols <- many $ do s <- parseLayerSep + lnm <- parseLayerName + return (s, lnm) + return $ LL l1 ols + + parse = quotedParse parseUnqt + `onFail` + liftM (flip LL []) (parseLayerName' `onFail` numString) + +-- ----------------------------------------------------------------------------- + +data OutputMode = BreadthFirst | NodesFirst | EdgesFirst + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot OutputMode where + unqtDot BreadthFirst = text "breadthfirst" + unqtDot NodesFirst = text "nodesfirst" + unqtDot EdgesFirst = text "edgesfirst" + +instance ParseDot OutputMode where + parseUnqt = oneOf [ stringRep BreadthFirst "breadthfirst" + , stringRep NodesFirst "nodesfirst" + , stringRep EdgesFirst "edgesfirst" + ] + +-- ----------------------------------------------------------------------------- + +data Pack = DoPack + | DontPack + | PackMargin Int -- ^ If non-negative, then packs; otherwise doesn't. + deriving (Eq, Ord, Show, Read) + +instance PrintDot Pack where + unqtDot DoPack = unqtDot True + unqtDot DontPack = unqtDot False + unqtDot (PackMargin m) = unqtDot m + +instance ParseDot Pack where + -- What happens if it parses 0? It's non-negative, but parses as False + parseUnqt = oneOf [ liftM PackMargin parseUnqt + , liftM (bool DontPack DoPack) onlyBool + ] + +-- ----------------------------------------------------------------------------- + +data PackMode = PackNode + | PackClust + | PackGraph + | PackArray Bool Bool (Maybe Int) -- ^ Sort by cols, sort + -- by user, number of + -- rows/cols + deriving (Eq, Ord, Show, Read) + +instance PrintDot PackMode where + unqtDot PackNode = text "node" + unqtDot PackClust = text "clust" + unqtDot PackGraph = text "graph" + unqtDot (PackArray c u mi) = addNum . isU . isC . isUnder + $ text "array" + where + addNum = maybe id (flip (<>) . unqtDot) mi + isUnder = if c || u + then flip (<>) $ char '_' + else id + isC = if c + then flip (<>) $ char 'c' + else id + isU = if u + then flip (<>) $ char 'u' + else id + +instance ParseDot PackMode where + parseUnqt = oneOf [ stringRep PackNode "node" + , stringRep PackClust "clust" + , stringRep PackGraph "graph" + , do string "array" + mcu <- optional $ do character '_' + many1 $ satisfy isCU + let c = hasCharacter mcu 'c' + u = hasCharacter mcu 'u' + mi <- optional parseUnqt + return $ PackArray c u mi + ] + where + hasCharacter ms c = maybe False (elem c) ms + -- Also checks and removes quote characters + isCU = flip elem ['c', 'u'] + +-- ----------------------------------------------------------------------------- + +data Pos = PointPos Point + | SplinePos [Spline] + deriving (Eq, Ord, Show, Read) + +instance PrintDot Pos where + unqtDot (PointPos p) = unqtDot p + unqtDot (SplinePos ss) = unqtDot ss + + toDot (PointPos p) = toDot p + toDot (SplinePos ss) = toDot ss + +instance ParseDot Pos where + -- Have to be careful with this: if we try to parse points first, + -- then a spline with no start and end points will erroneously get + -- parsed as a point and then the parser will crash as it expects + -- a closing quote character... + parseUnqt = do splns <- parseUnqt + case splns of + [Spline Nothing Nothing [p]] -> return $ PointPos p + _ -> return $ SplinePos splns + + parse = quotedParse parseUnqt + +-- ----------------------------------------------------------------------------- + +-- | Controls how (and if) edges are represented. +data EdgeType = SplineEdges + | LineEdges + | NoEdges + | PolyLine + | CompoundEdge -- ^ fdp only + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot EdgeType where + unqtDot SplineEdges = toDot True + unqtDot LineEdges = toDot False + unqtDot NoEdges = empty + unqtDot PolyLine = text "polyline" + unqtDot CompoundEdge = text "compound" + + toDot NoEdges = doubleQuotes empty + toDot et = unqtDot et + +instance ParseDot EdgeType where + -- Can't parse NoEdges without quotes. + parseUnqt = oneOf [ liftM (bool LineEdges SplineEdges) parse + , stringRep SplineEdges "spline" + , stringRep LineEdges "line" + , stringRep PolyLine "polyline" + , stringRep CompoundEdge "compound" + ] + + parse = stringRep NoEdges "\"\"" + `onFail` + optionalQuoted parseUnqt + +-- ----------------------------------------------------------------------------- + +-- | Upper-case first character is major order; +-- lower-case second character is minor order. +data PageDir = Bl | Br | Tl | Tr | Rb | Rt | Lb | Lt + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot PageDir where + unqtDot Bl = text "BL" + unqtDot Br = text "BR" + unqtDot Tl = text "TL" + unqtDot Tr = text "TR" + unqtDot Rb = text "RB" + unqtDot Rt = text "RT" + unqtDot Lb = text "LB" + unqtDot Lt = text "LT" + +instance ParseDot PageDir where + parseUnqt = oneOf [ stringRep Bl "BL" + , stringRep Br "BR" + , stringRep Tl "TL" + , stringRep Tr "TR" + , stringRep Rb "RB" + , stringRep Rt "RT" + , stringRep Lb "LB" + , stringRep Lt "LT" + ] + +-- ----------------------------------------------------------------------------- + +-- | The number of points in the list must be equivalent to 1 mod 3; +-- note that this is not checked. +data Spline = Spline (Maybe Point) (Maybe Point) [Point] + deriving (Eq, Ord, Show, Read) + +instance PrintDot Spline where + unqtDot (Spline ms me ps) = addS . addE + . hsep + $ map unqtDot ps + where + addP t = maybe id ((<+>) . commaDel t) + addS = addP 's' ms + addE = addP 'e' me + + toDot = doubleQuotes . unqtDot + + unqtListToDot = hcat . punctuate semi . map unqtDot + + listToDot = doubleQuotes . unqtListToDot + +instance ParseDot Spline where + parseUnqt = do ms <- parseP 's' + me <- parseP 'e' + ps <- sepBy1 parseUnqt whitespace + return $ Spline ms me ps + where + parseP t = optional $ do character t + parseComma + parseUnqt `discard` whitespace + + parse = quotedParse parseUnqt + + parseUnqtList = sepBy1 parseUnqt (character ';') + +-- ----------------------------------------------------------------------------- + +data QuadType = NormalQT + | FastQT + | NoQT + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot QuadType where + unqtDot NormalQT = text "normal" + unqtDot FastQT = text "fast" + unqtDot NoQT = text "none" + +instance ParseDot QuadType where + -- Have to take into account the slightly different interpretation + -- of Bool used as an option for parsing QuadType + parseUnqt = oneOf [ stringRep NormalQT "normal" + , stringRep FastQT "fast" + , stringRep NoQT "none" + , character '2' >> return FastQT -- weird bool + , liftM (bool NoQT NormalQT) parse + ] + +-- ----------------------------------------------------------------------------- + +-- | Specify the root node either as a Node attribute or a Graph attribute. +data Root = IsCentral -- ^ For Nodes only + | NotCentral -- ^ For Nodes only + | NodeName String -- ^ For Graphs only + deriving (Eq, Ord, Show, Read) + +instance PrintDot Root where + unqtDot IsCentral = unqtDot True + unqtDot NotCentral = unqtDot False + unqtDot (NodeName n) = unqtDot n + + toDot (NodeName n) = toDot n + toDot r = unqtDot r + +instance ParseDot Root where + parseUnqt = liftM (bool NotCentral IsCentral) onlyBool + `onFail` + liftM NodeName parseUnqt + + parse = optionalQuoted (liftM (bool NotCentral IsCentral) onlyBool) + `onFail` + liftM NodeName parse + +-- ----------------------------------------------------------------------------- + +data RankType = SameRank + | MinRank + | SourceRank + | MaxRank + | SinkRank + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot RankType where + unqtDot SameRank = text "same" + unqtDot MinRank = text "min" + unqtDot SourceRank = text "source" + unqtDot MaxRank = text "max" + unqtDot SinkRank = text "sink" + +instance ParseDot RankType where + parseUnqt = oneOf [ stringRep SameRank "same" + , stringRep MinRank "min" + , stringRep SourceRank "source" + , stringRep MaxRank "max" + , stringRep SinkRank "sink" + ] + +-- ----------------------------------------------------------------------------- + +data RankDir = FromTop + | FromLeft + | FromBottom + | FromRight + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot RankDir where + unqtDot FromTop = text "TB" + unqtDot FromLeft = text "LR" + unqtDot FromBottom = text "BT" + unqtDot FromRight = text "RL" + +instance ParseDot RankDir where + parseUnqt = oneOf [ stringRep FromTop "TB" + , stringRep FromLeft "LR" + , stringRep FromBottom "BT" + , stringRep FromRight "RL" + ] + +-- ----------------------------------------------------------------------------- + +data Shape + = BoxShape -- ^ Has synonyms of /rect/ and /rectangle/. + | Polygon + | Ellipse + | Circle + | PointShape + | Egg + | Triangle + | PlainText -- ^ Has synonym of /none/. + | DiamondShape + | Trapezium + | Parallelogram + | House + | Pentagon + | Hexagon + | Septagon + | Octagon + | DoubleCircle + | DoubleOctagon + | TripleOctagon + | InvTriangle + | InvTrapezium + | InvHouse + | MDiamond + | MSquare + | MCircle + | Note + | Tab + | Folder + | Box3D + | Component + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot Shape where + unqtDot BoxShape = text "box" + unqtDot Polygon = text "polygon" + unqtDot Ellipse = text "ellipse" + unqtDot Circle = text "circle" + unqtDot PointShape = text "point" + unqtDot Egg = text "egg" + unqtDot Triangle = text "triangle" + unqtDot PlainText = text "plaintext" + unqtDot DiamondShape = text "diamond" + unqtDot Trapezium = text "trapezium" + unqtDot Parallelogram = text "parallelogram" + unqtDot House = text "house" + unqtDot Pentagon = text "pentagon" + unqtDot Hexagon = text "hexagon" + unqtDot Septagon = text "septagon" + unqtDot Octagon = text "octagon" + unqtDot DoubleCircle = text "doublecircle" + unqtDot DoubleOctagon = text "doubleoctagon" + unqtDot TripleOctagon = text "tripleoctagon" + unqtDot InvTriangle = text "invtriangle" + unqtDot InvTrapezium = text "invtrapezium" + unqtDot InvHouse = text "invhouse" + unqtDot MDiamond = text "Mdiamond" + unqtDot MSquare = text "Msquare" + unqtDot MCircle = text "Mcircle" + unqtDot Note = text "note" + unqtDot Tab = text "tab" + unqtDot Folder = text "folder" + unqtDot Box3D = text "box3d" + unqtDot Component = text "component" + +instance ParseDot Shape where + parseUnqt = oneOf [ stringRep Box3D "box3d" -- Parse this before "box" + , stringReps BoxShape ["box","rectangle","rect"] + , stringRep Polygon "polygon" + , stringRep Ellipse "ellipse" + , stringRep Circle "circle" + , stringRep PointShape "point" + , stringRep Egg "egg" + , stringRep Triangle "triangle" + , stringReps PlainText ["plaintext","none"] + , stringRep DiamondShape "diamond" + , stringRep Trapezium "trapezium" + , stringRep Parallelogram "parallelogram" + , stringRep House "house" + , stringRep Pentagon "pentagon" + , stringRep Hexagon "hexagon" + , stringRep Septagon "septagon" + , stringRep Octagon "octagon" + , stringRep DoubleCircle "doublecircle" + , stringRep DoubleOctagon "doubleoctagon" + , stringRep TripleOctagon "tripleoctagon" + , stringRep InvTriangle "invtriangle" + , stringRep InvTrapezium "invtrapezium" + , stringRep InvHouse "invhouse" + , stringRep MDiamond "Mdiamond" + , stringRep MSquare "Msquare" + , stringRep MCircle "Mcircle" + , stringRep Note "note" + , stringRep Tab "tab" + , stringRep Folder "folder" + , stringRep Component "component" + ] + +-- ----------------------------------------------------------------------------- + +data SmoothType = NoSmooth + | AvgDist + | GraphDist + | PowerDist + | RNG + | Spring + | TriangleSmooth + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot SmoothType where + unqtDot NoSmooth = text "none" + unqtDot AvgDist = text "avg_dist" + unqtDot GraphDist = text "graph_dist" + unqtDot PowerDist = text "power_dist" + unqtDot RNG = text "rng" + unqtDot Spring = text "spring" + unqtDot TriangleSmooth = text "triangle" + +instance ParseDot SmoothType where + parseUnqt = oneOf [ stringRep NoSmooth "none" + , stringRep AvgDist "avg_dist" + , stringRep GraphDist "graph_dist" + , stringRep PowerDist "power_dist" + , stringRep RNG "rng" + , stringRep Spring "spring" + , stringRep TriangleSmooth "triangle" + ] + +-- ----------------------------------------------------------------------------- + +data StartType = StartStyle STStyle + | StartSeed Int + | StartStyleSeed STStyle Int + deriving (Eq, Ord, Show, Read) + +instance PrintDot StartType where + unqtDot (StartStyle ss) = unqtDot ss + unqtDot (StartSeed s) = unqtDot s + unqtDot (StartStyleSeed ss s) = unqtDot ss <> unqtDot s + +instance ParseDot StartType where + parseUnqt = oneOf [ do ss <- parseUnqt + s <- parseUnqt + return $ StartStyleSeed ss s + , liftM StartStyle parseUnqt + , liftM StartSeed parseUnqt + ] + +data STStyle = RegularStyle + | SelfStyle + | RandomStyle + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot STStyle where + unqtDot RegularStyle = text "regular" + unqtDot SelfStyle = text "self" + unqtDot RandomStyle = text "random" + +instance ParseDot STStyle where + parseUnqt = oneOf [ stringRep RegularStyle "regular" + , stringRep SelfStyle "self" + , stringRep RandomStyle "random" + ] + +-- ----------------------------------------------------------------------------- + +data StyleItem = SItem StyleName [String] + deriving (Eq, Ord, Show, Read) + +instance PrintDot StyleItem where + unqtDot (SItem nm args) + | null args = dnm + | otherwise = dnm <> parens args' + where + dnm = unqtDot nm + args' = hcat . punctuate comma $ map unqtDot args + + toDot si@(SItem nm args) + | null args = toDot nm + | otherwise = doubleQuotes $ unqtDot si + + unqtListToDot = hcat . punctuate comma . map unqtDot + + listToDot [SItem nm []] = toDot nm + listToDot sis = doubleQuotes $ unqtListToDot sis + +instance ParseDot StyleItem where + parseUnqt = do nm <- parseUnqt + args <- tryParseList' parseArgs + return $ SItem nm args + + parse = quotedParse (liftM2 SItem parseUnqt parseArgs) + `onFail` + liftM (flip SItem []) parse + + parseUnqtList = sepBy1 parseUnqt parseComma + + parseList = quotedParse parseUnqtList + `onFail` + -- Might not necessarily need to be quoted if a singleton... + liftM return parse + +parseArgs :: Parse [String] +parseArgs = bracketSep (character '(') + parseComma + (character ')') + parseStyleName + +data StyleName = Dashed -- ^ Nodes and Edges + | Dotted -- ^ Nodes and Edges + | Solid -- ^ Nodes and Edges + | Bold -- ^ Nodes and Edges + | Invisible -- ^ Nodes and Edges + | Filled -- ^ Nodes and Clusters + | Diagonals -- ^ Nodes only + | Rounded -- ^ Nodes and Clusters + | DD String -- ^ Device Dependent + deriving (Eq, Ord, Show, Read) + +instance PrintDot StyleName where + unqtDot Dashed = text "dashed" + unqtDot Dotted = text "dotted" + unqtDot Solid = text "solid" + unqtDot Bold = text "bold" + unqtDot Invisible = text "invis" + unqtDot Filled = text "filled" + unqtDot Diagonals = text "diagonals" + unqtDot Rounded = text "rounded" + unqtDot (DD nm) = unqtDot nm + + toDot (DD nm) = toDot nm + toDot sn = unqtDot sn + +instance ParseDot StyleName where + parseUnqt = liftM checkDD parseStyleName + + parse = liftM checkDD + $ quotedParse parseStyleName + `onFail` + -- In case a singleton DD is at the end of an attribute list. + do f <- orQuote $ noneOf [quoteChar, '(', ')', ',', ' ', ']'] + r <- many (orQuote $ noneOf [quoteChar, '(', ')', ',', ']']) + return $ f:r + +checkDD :: String -> StyleName +checkDD str = case map toLower str of + "dashed" -> Dashed + "dotted" -> Dotted + "solid" -> Solid + "bold" -> Bold + "invis" -> Invisible + "filled" -> Filled + "diagonals" -> Diagonals + "rounded" -> Rounded + _ -> DD str + +parseStyleName :: Parse String +parseStyleName = do f <- orQuote $ noneOf [quoteChar, '(', ')', ',', ' '] + r <- many (orQuote $ noneOf [quoteChar, '(', ')', ',']) + return $ f:r + +-- ----------------------------------------------------------------------------- + +newtype PortPos = PP CompassPoint + deriving (Eq, Ord, Show, Read) + +instance PrintDot PortPos where + unqtDot (PP cp) = unqtDot cp + + toDot (PP cp) = toDot cp + +instance ParseDot PortPos where + parseUnqt = liftM PP parseUnqt + +data CompassPoint = North + | NorthEast + | East + | SouthEast + | South + | SouthWest + | West + | NorthWest + | CenterPoint + | NoCP + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot CompassPoint where + unqtDot NorthEast = text "ne" + unqtDot NorthWest = text "nw" + unqtDot North = text "n" + unqtDot East = text "e" + unqtDot SouthEast = text "se" + unqtDot SouthWest = text "sw" + unqtDot South = text "s" + unqtDot West = text "w" + unqtDot CenterPoint = text "c" + unqtDot NoCP = text "_" + +instance ParseDot CompassPoint where + -- Have to take care of longer parsing values first. + parseUnqt = oneOf [ stringRep NorthEast "ne" + , stringRep NorthWest "nw" + , stringRep North "n" + , stringRep SouthEast "se" + , stringRep SouthWest "sw" + , stringRep South "s" + , stringRep East "e" + , stringRep West "w" + , stringRep CenterPoint "c" + , stringRep NoCP "_" + ] + +-- ----------------------------------------------------------------------------- + +data ViewPort = VP { wVal :: Double + , hVal :: Double + , zVal :: Double + , focus :: Maybe FocusType + } + deriving (Eq, Ord, Show, Read) + +instance PrintDot ViewPort where + unqtDot vp = maybe vs ((<>) (vs <> comma) . unqtDot) + $ focus vp + where + vs = hcat . punctuate comma + $ map (unqtDot . flip ($) vp) [wVal, hVal, zVal] + + toDot = doubleQuotes . unqtDot + +instance ParseDot ViewPort where + parseUnqt = do wv <- parseUnqt + parseComma + hv <- parseUnqt + parseComma + zv <- parseUnqt + mf <- optional $ parseComma >> parseUnqt + return $ VP wv hv zv mf + + parse = quotedParse parseUnqt + +data FocusType = XY Point + | NodeFocus String + deriving (Eq, Ord, Show, Read) + +instance PrintDot FocusType where + unqtDot (XY p) = unqtDot p + unqtDot (NodeFocus nm) = unqtDot nm + + toDot (XY p) = toDot p + toDot (NodeFocus nm) = toDot nm + +instance ParseDot FocusType where + parseUnqt = liftM XY parseUnqt + `onFail` + liftM NodeFocus parseUnqt + + parse = liftM XY parse + `onFail` + liftM NodeFocus parse + +-- ----------------------------------------------------------------------------- + +data VerticalPlacement = VTop + | VCenter -- ^ Only valid for Nodes. + | VBottom + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot VerticalPlacement where + unqtDot VTop = char 't' + unqtDot VCenter = char 'c' + unqtDot VBottom = char 'b' + +instance ParseDot VerticalPlacement where + parseUnqt = oneOf [ stringRep VTop "t" + , stringRep VCenter "c" + , stringRep VBottom "b" + ] + +-- ----------------------------------------------------------------------------- + +data ScaleType = UniformScale + | NoScale + | FillWidth + | FillHeight + | FillBoth + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot ScaleType where + unqtDot UniformScale = unqtDot True + unqtDot NoScale = unqtDot False + unqtDot FillWidth = text "width" + unqtDot FillHeight = text "height" + unqtDot FillBoth = text "both" + +instance ParseDot ScaleType where + parseUnqt = oneOf [ stringRep UniformScale "true" + , stringRep NoScale "false" + , stringRep FillWidth "width" + , stringRep FillHeight "height" + , stringRep FillBoth "both" + ] + +-- ----------------------------------------------------------------------------- + +data Justification = JLeft + | JRight + | JCenter + deriving (Eq, Ord, Bounded, Enum, Show, Read) + +instance PrintDot Justification where + unqtDot JLeft = char 'l' + unqtDot JRight = char 'r' + unqtDot JCenter = char 'c' + +instance ParseDot Justification where + parseUnqt = oneOf [ stringRep JLeft "l" + , stringRep JRight "r" + , stringRep JCenter "c" + ] + +-- ----------------------------------------------------------------------------- + +data Ratios = AspectRatio Double + | FillRatio + | CompressRatio + | ExpandRatio + | AutoRatio + deriving (Eq, Ord, Show, Read) + +instance PrintDot Ratios where + unqtDot (AspectRatio r) = unqtDot r + unqtDot FillRatio = text "fill" + unqtDot CompressRatio = text "compress" + unqtDot ExpandRatio = text "expand" + unqtDot AutoRatio = text "auto" + +instance ParseDot Ratios where + parseUnqt = oneOf [ liftM AspectRatio parseUnqt + , stringRep FillRatio "fill" + , stringRep CompressRatio "compress" + , stringRep ExpandRatio "expand" + , stringRep AutoRatio "auto" + ] diff --git a/Test/examples/BangPatterns.hs b/Test/examples/BangPatterns.hs new file mode 100644 --- /dev/null +++ b/Test/examples/BangPatterns.hs @@ -0,0 +1,8 @@ +{-# LANGUAGE BangPatterns #-} +module BangPatterns where + +firstnonspace :: Ptr Word8 -> Int -> Int -> IO Int +firstnonspace !ptr !n !m + | n >= m = return n + | otherwise = do w <- peekElemOff ptr n + if isSpaceWord8 w then firstnonspace ptr (n+1) m else return n diff --git a/Test/examples/Bug.hs b/Test/examples/Bug.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Bug.hs @@ -0,0 +1,2 @@ +import Test.QuickCheck +-- prop_susShortest = 2 > 1 ==> 1 /= 2 diff --git a/Test/examples/ByteStringUtils.hs b/Test/examples/ByteStringUtils.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ByteStringUtils.hs @@ -0,0 +1,541 @@ +{-# LANGUAGE BangPatterns, ForeignFunctionInterface, CPP #-} + +----------------------------------------------------------------------------- +-- | +-- Module : ByteStringUtils +-- Copyright : (c) The University of Glasgow 2001, +-- David Roundy 2003-2005 +-- License : GPL (I'm happy to also license this file BSD style but don't +-- want to bother distributing two license files with darcs. +-- +-- Maintainer : droundy@abridgegame.org +-- Stability : experimental +-- Portability : portable +-- +-- GZIp and MMap IO for ByteStrings, and miscellaneous functions for Data.ByteString +-- + +module ByteStringUtils ( + + unsafeWithInternals, + unpackPSfromUTF8, + + -- IO with mmap or gzip + gzReadFilePS, + mmapFilePS, + gzWriteFilePS, + gzWriteFilePSs, + + -- list utilities + ifHeadThenTail, + dropSpace, + breakSpace, + linesPS, + unlinesPS, + hashPS, + breakFirstPS, + breakLastPS, + substrPS, + readIntPS, + is_funky, + fromHex2PS, + fromPS2Hex, + betweenLinesPS, + break_after_nth_newline, + break_before_nth_newline, + intercalate + ) where + +import Prelude hiding ( catch ) +import qualified Data.ByteString as B +import qualified Data.ByteString.Char8 as BC +import qualified Data.ByteString.Internal as BI +import Data.ByteString (intercalate, uncons) +import Data.ByteString.Internal (fromForeignPtr) + +-- #if defined (HAVE_MMAP) || ! defined (HAVE_HASKELL_ZLIB) +import Control.Exception ( catch ) +-- #endif +import System.IO +import System.IO.Unsafe ( unsafePerformIO ) + +import Foreign.Storable ( peekElemOff, peek ) +import Foreign.Marshal.Alloc ( free ) +import Foreign.Marshal.Array ( mallocArray, peekArray, advancePtr ) +import Foreign.C.Types ( CInt ) + +import Data.Bits ( rotateL ) +import Data.Char ( chr, ord, isSpace ) +import Data.Word ( Word8 ) +import Data.Int ( Int32 ) +import Control.Monad ( when ) + +-- #ifndef HAVE_HASKELL_ZLIB +import Foreign.Ptr ( nullPtr ) +import Foreign.ForeignPtr ( ForeignPtr ) +-- #endif +import Foreign.Ptr ( plusPtr, Ptr ) +import Foreign.ForeignPtr ( withForeignPtr ) + +-- #ifdef DEBUG_PS +import Foreign.ForeignPtr ( addForeignPtrFinalizer ) +import Foreign.Ptr ( FunPtr ) +-- #endif + +-- #if HAVE_HASKELL_ZLIB +import qualified Data.ByteString.Lazy as BL +import qualified Codec.Compression.GZip as GZ +-- #else +import Foreign.C.String ( CString, withCString ) +-- #endif + +-- #ifdef HAVE_MMAP +import System.IO.MMap( mmapFileByteString ) +import System.Mem( performGC ) +import System.Posix.Files( fileSize, getSymbolicLinkStatus ) +-- #endif + +-- ----------------------------------------------------------------------------- +-- obsolete debugging code + +-- # ifndef HAVE_HASKELL_ZLIB +debugForeignPtr :: ForeignPtr a -> String -> IO () +-- #ifdef DEBUG_PS +foreign import ccall unsafe "static fpstring.h debug_alloc" debug_alloc + :: Ptr a -> CString -> IO () +foreign import ccall unsafe "static fpstring.h & debug_free" debug_free + :: FunPtr (Ptr a -> IO ()) +debugForeignPtr fp n = + withCString n $ \cname-> withForeignPtr fp $ \p-> + do debug_alloc p cname + addForeignPtrFinalizer debug_free fp +-- #else +debugForeignPtr _ _ = return () +-- #endif +-- #endif + +-- ----------------------------------------------------------------------------- +-- unsafeWithInternals + +-- | Do something with the internals of a PackedString. Beware of +-- altering the contents! +unsafeWithInternals :: B.ByteString -> (Ptr Word8 -> Int -> IO a) -> IO a +unsafeWithInternals ps f + = case BI.toForeignPtr ps of + (fp,s,l) -> withForeignPtr fp $ \p -> f (p `plusPtr` s) l + +-- | readIntPS skips any whitespace at the beginning of its argument, and +-- reads an Int from the beginning of the PackedString. If there is no +-- integer at the beginning of the string, it returns Nothing, otherwise it +-- just returns the int read, along with a B.ByteString containing the +-- remainder of its input. + +readIntPS :: B.ByteString -> Maybe (Int, B.ByteString) +readIntPS = BC.readInt . BC.dropWhile isSpace + +-- ----------------------------------------------------------------------------- +-- Destructor functions (taking PackedStrings apart) + +unpackPSfromUTF8 :: B.ByteString -> String +unpackPSfromUTF8 ps = + case BI.toForeignPtr ps of + (_,_, 0) -> "" + (x,s,l) -> + unsafePerformIO $ withForeignPtr x $ \p-> + do outbuf <- mallocArray l + lout <- fromIntegral `fmap` + utf8_to_ints outbuf (p `plusPtr` s) (fromIntegral l) + when (lout < 0) $ error "Bad UTF8!" + str <- (map (chr . fromIntegral)) `fmap` peekArray lout outbuf + free outbuf + return str + +foreign import ccall unsafe "static fpstring.h utf8_to_ints" utf8_to_ints + :: Ptr Int -> Ptr Word8 -> CInt -> IO CInt + +-- ----------------------------------------------------------------------------- +-- List-mimicking functions for PackedStrings + +{-# INLINE ifHeadThenTail #-} +ifHeadThenTail :: Word8 -> B.ByteString -> Maybe B.ByteString +ifHeadThenTail c s = case uncons s of + Just (w, t) | w == c -> Just t + _ -> Nothing + +------------------------------------------------------------------------ +-- A reimplementation of Data.ByteString.Char8.dropSpace, but +-- specialised to darcs' need for a 4 way isspace. +-- +-- TODO: if it is safe to use the expanded definition of isSpaceWord8 +-- provided by Data.ByteString.Char8, then all this can go. + +-- A locale-independent isspace(3) so patches are interpreted the same everywhere. +-- ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\r') +isSpaceWord8 :: Word8 -> Bool +isSpaceWord8 w = + w == 0x20 || -- ' ' + w == 0x09 || -- '\t' + w == 0x0A || -- '\n' + w == 0x0D -- '\r' +{-# INLINE isSpaceWord8 #-} + +firstnonspace :: Ptr Word8 -> Int -> Int -> IO Int +firstnonspace !ptr !n !m + | n >= m = return n + | otherwise = do w <- peekElemOff ptr n + if isSpaceWord8 w then firstnonspace ptr (n+1) m else return n + +firstspace :: Ptr Word8 -> Int -> Int -> IO Int +firstspace !ptr !n !m + | n >= m = return n + | otherwise = do w <- peekElemOff ptr n + if (not . isSpaceWord8) w then firstspace ptr (n+1) m else return n + +-- | 'dropSpace' efficiently returns the 'ByteString' argument with +-- white space Chars removed from the front. It is more efficient than +-- calling dropWhile for removing whitespace. I.e. +-- +-- > dropWhile isSpace == dropSpace +-- +dropSpace :: B.ByteString -> B.ByteString +dropSpace (BI.PS x s l) = BI.inlinePerformIO $ withForeignPtr x $ \p -> do + i <- firstnonspace (p `plusPtr` s) 0 l + return $! if i == l then B.empty else BI.PS x (s+i) (l-i) +{-# INLINE dropSpace #-} + +-- | 'breakSpace' returns the pair of ByteStrings when the argument is +-- broken at the first whitespace byte. I.e. +-- +-- > break isSpace == breakSpace +-- +breakSpace :: B.ByteString -> (B.ByteString,B.ByteString) +breakSpace (BI.PS x s l) = BI.inlinePerformIO $ withForeignPtr x $ \p -> do + i <- firstspace (p `plusPtr` s) 0 l + return $! case () of {_ + | i == 0 -> (B.empty, BI.PS x s l) + | i == l -> (BI.PS x s l, B.empty) + | otherwise -> (BI.PS x s i, BI.PS x (s+i) (l-i)) + } +{-# INLINE breakSpace #-} + +------------------------------------------------------------------------ + +{-# INLINE is_funky #-} +is_funky :: B.ByteString -> Bool +is_funky ps = case BI.toForeignPtr ps of + (x,s,l) -> + unsafePerformIO $ withForeignPtr x $ \p-> + (/=0) `fmap` has_funky_char (p `plusPtr` s) (fromIntegral l) + +foreign import ccall unsafe "fpstring.h has_funky_char" has_funky_char + :: Ptr Word8 -> CInt -> IO CInt + +------------------------------------------------------------------------ + +-- ByteString rewrites break (=='x') to breakByte 'x' +-- break ((==) x) = breakChar x +-- break (==x) = breakChar x +-- + +{- +{-# INLINE breakOnPS #-} +breakOnPS :: Char -> B.ByteString -> (B.ByteString, B.ByteString) +breakOnPS c p = case BC.elemIndex c p of + Nothing -> (p, BC.empty) + Just n -> (B.take n p, B.drop n p) +-} + +{-# INLINE hashPS #-} +hashPS :: B.ByteString -> Int32 +hashPS ps = + case BI.toForeignPtr ps of + (x,s,l) -> + unsafePerformIO $ withForeignPtr x $ \p-> + do hash (p `plusPtr` s) l + +hash :: Ptr Word8 -> Int -> IO Int32 +hash ptr len = f (0 :: Int32) ptr len + where f h _ 0 = return h + f h p n = do x <- peek p + let !h' = (fromIntegral x) + (rotateL h 8) + f h' (p `advancePtr` 1) (n-1) + +{-# INLINE substrPS #-} +substrPS :: B.ByteString -> B.ByteString -> Maybe Int +substrPS tok str + | B.null tok = Just 0 + | B.length tok > B.length str = Nothing + | otherwise = do n <- BC.elemIndex (BC.head tok) str + let ttok = B.tail tok + reststr = B.drop (n+1) str + if ttok == B.take (B.length ttok) reststr + then Just n + else ((n+1)+) `fmap` substrPS tok reststr + +------------------------------------------------------------------------ + +-- TODO: replace breakFirstPS and breakLastPS with definitions based on +-- ByteString's break/breakEnd +{-# INLINE breakFirstPS #-} +breakFirstPS :: Char -> B.ByteString -> Maybe (B.ByteString,B.ByteString) +breakFirstPS c p = case BC.elemIndex c p of + Nothing -> Nothing + Just n -> Just (B.take n p, B.drop (n+1) p) + +{-# INLINE breakLastPS #-} +breakLastPS :: Char -> B.ByteString -> Maybe (B.ByteString,B.ByteString) +breakLastPS c p = case BC.elemIndexEnd c p of + Nothing -> Nothing + Just n -> Just (B.take n p, B.drop (n+1) p) + +-- TODO: rename +{-# INLINE linesPS #-} +linesPS :: B.ByteString -> [B.ByteString] +linesPS ps + | B.null ps = [B.empty] + | otherwise = BC.split '\n' ps + +{- QuickCheck property: + +import Test.QuickCheck +import qualified Data.ByteString.Char8 as BC +import Data.Char +instance Arbitrary BC.ByteString where + arbitrary = fmap BC.pack arbitrary +instance Arbitrary Char where + arbitrary = chr `fmap` choose (32,127) +deepCheck = check (defaultConfig { configMaxTest = 10000}) +testLines = deepCheck (\x -> (linesPS x == linesPSOld x)) +linesPSOld ps = case BC.elemIndex '\n' ps of + Nothing -> [ps] + Just n -> B.take n ps : linesPS (B.drop (n+1) ps) -} + +{-| This function acts exactly like the "Prelude" unlines function, or like +"Data.ByteString.Char8" 'unlines', but with one important difference: it will +produce a string which may not end with a newline! That is: + +> unlinesPS ["foo", "bar"] + +evaluates to \"foo\\nbar\", not \"foo\\nbar\\n\"! This point should hold true for +'linesPS' as well. + +TODO: rename this function. -} +unlinesPS :: [B.ByteString] -> B.ByteString +unlinesPS [] = BC.empty +unlinesPS x = BC.init $ BC.unlines x +{-# INLINE unlinesPS #-} +{- QuickCheck property: + +testUnlines = deepCheck (\x -> (unlinesPS x == unlinesPSOld x)) +unlinesPSOld ss = BC.concat $ intersperse_newlines ss + where intersperse_newlines (a:b:s) = a : newline : intersperse_newlines (b:s) + intersperse_newlines s = s + newline = BC.pack "\n" -} + +-- ----------------------------------------------------------------------------- +-- gzReadFilePS + +-- | Read an entire file, which may or may not be gzip compressed, directly +-- into a 'B.ByteString'. + +-- #ifndef HAVE_HASKELL_ZLIB +foreign import ccall unsafe "static zlib.h gzopen" c_gzopen + :: CString -> CString -> IO (Ptr ()) +foreign import ccall unsafe "static zlib.h gzclose" c_gzclose + :: Ptr () -> IO () +foreign import ccall unsafe "static zlib.h gzread" c_gzread + :: Ptr () -> Ptr Word8 -> CInt -> IO CInt +foreign import ccall unsafe "static zlib.h gzwrite" c_gzwrite + :: Ptr () -> Ptr Word8 -> CInt -> IO CInt +-- #endif + +gzReadFilePS :: FilePath -> IO B.ByteString +gzReadFilePS f = do + h <- openBinaryFile f ReadMode + header <- B.hGet h 2 + if header /= BC.pack "\31\139" + then do hClose h + mmapFilePS f + else do hSeek h SeekFromEnd (-4) + len <- hGetLittleEndInt h + hClose h +-- #ifdef HAVE_HASKELL_ZLIB + -- Passing the length to GZ.decompressWith means + -- that BL.toChunks only produces one chunk, which in turn + -- means that B.concat won't need to copy data. + -- If the length is wrong this will just affect efficiency, not correctness + let decompress = GZ.decompressWith GZ.defaultDecompressParams { + GZ.decompressBufferSize = len + } + fmap (B.concat . BL.toChunks . decompress) $ +-- #ifdef HAVE_OLD_BYTESTRING + -- bytestring < 0.9.1 had a bug where it did not know to close handles upon EOF + -- performance would be better with a newer bytestring and lazy + -- readFile below -- ratify readFile: comment + fmap (BL.fromChunks . (:[])) $ + B.readFile f -- ratify readFile: immediately consumed +-- #else + BL.readFile f -- ratify readFile: immediately consumed by the conversion to a strict bytestring +-- #endif +-- #else + withCString f $ \fstr-> withCString "rb" $ \rb-> do + gzf <- c_gzopen fstr rb + when (gzf == nullPtr) $ fail $ "problem opening file "++f + fp <- BI.mallocByteString len + debugForeignPtr fp $ "gzReadFilePS "++f + lread <- withForeignPtr fp $ \p -> + c_gzread gzf p (fromIntegral len) + c_gzclose gzf + when (fromIntegral lread /= len) $ + fail $ "problem gzreading file "++f + return $ fromForeignPtr fp 0 len +-- #endif + +hGetLittleEndInt :: Handle -> IO Int +hGetLittleEndInt h = do + b1 <- ord `fmap` hGetChar h + b2 <- ord `fmap` hGetChar h + b3 <- ord `fmap` hGetChar h + b4 <- ord `fmap` hGetChar h + return $ b1 + 256*b2 + 65536*b3 + 16777216*b4 + +gzWriteFilePS :: FilePath -> B.ByteString -> IO () +gzWriteFilePS f ps = gzWriteFilePSs f [ps] + +gzWriteFilePSs :: FilePath -> [B.ByteString] -> IO () +gzWriteFilePSs f pss = +-- #ifdef HAVE_HASKELL_ZLIB + BL.writeFile f $ GZ.compress $ BL.fromChunks pss +-- #else + withCString f $ \fstr -> withCString "wb" $ \wb -> do + gzf <- c_gzopen fstr wb + when (gzf == nullPtr) $ fail $ "problem gzopening file for write: "++f + mapM_ (gzWriteToGzf gzf) pss `catch` + \_ -> fail $ "problem gzwriting file: "++f + c_gzclose gzf + +gzWriteToGzf :: Ptr () -> B.ByteString -> IO () +gzWriteToGzf gzf ps = case BI.toForeignPtr ps of + (_,_,0) -> return () -- avoid calling gzwrite with 0 length this would + -- trouble on some versions of zlib, and is always + -- unnecessary. + (x,s,l) -> do + lw <- withForeignPtr x $ \p -> c_gzwrite gzf (p `plusPtr` s) + (fromIntegral l) + when (fromIntegral lw /= l) $ fail $ "problem in gzWriteToGzf" +-- #endif + +-- ----------------------------------------------------------------------------- +-- mmapFilePS + +-- | Like readFilePS, this reads an entire file directly into a +-- 'B.ByteString', but it is even more efficient. It involves directly +-- mapping the file to memory. This has the advantage that the contents of +-- the file never need to be copied. Also, under memory pressure the page +-- may simply be discarded, wile in the case of readFilePS it would need to +-- be written to swap. If you read many small files, mmapFilePS will be +-- less memory-efficient than readFilePS, since each mmapFilePS takes up a +-- separate page of memory. Also, you can run into bus errors if the file +-- is modified. NOTE: as with 'readFilePS', the string representation in +-- the file is assumed to be ISO-8859-1. + +mmapFilePS :: FilePath -> IO B.ByteString +-- #ifdef HAVE_MMAP +mmapFilePS f = do + x <- mmapFileByteString f Nothing + `catch` (\_ -> do + size <- fileSize `fmap` getSymbolicLinkStatus f + if size == 0 + then return B.empty + else performGC >> mmapFileByteString f Nothing) + return x +-- #else +mmapFilePS = B.readFile +-- #endif + +-- ------------------------------------------------------------------------- +-- fromPS2Hex + +foreign import ccall unsafe "static fpstring.h conv_to_hex" conv_to_hex + :: Ptr Word8 -> Ptr Word8 -> CInt -> IO () + +fromPS2Hex :: B.ByteString -> B.ByteString +fromPS2Hex ps = case BI.toForeignPtr ps of + (x,s,l) -> + BI.unsafeCreate (2*l) $ \p -> withForeignPtr x $ \f -> + conv_to_hex p (f `plusPtr` s) $ fromIntegral l + +-- ------------------------------------------------------------------------- +-- fromHex2PS + +foreign import ccall unsafe "static fpstring.h conv_from_hex" conv_from_hex + :: Ptr Word8 -> Ptr Word8 -> CInt -> IO () + +fromHex2PS :: B.ByteString -> B.ByteString +fromHex2PS ps = case BI.toForeignPtr ps of + (x,s,l) -> + BI.unsafeCreate (l `div` 2) $ \p -> withForeignPtr x $ \f -> + conv_from_hex p (f `plusPtr` s) (fromIntegral $ l `div` 2) + +-- ------------------------------------------------------------------------- +-- betweenLinesPS + +-- | betweenLinesPS returns the B.ByteString between the two lines given, +-- or Nothing if they do not appear. + +betweenLinesPS :: B.ByteString -> B.ByteString -> B.ByteString + -> Maybe (B.ByteString) +betweenLinesPS start end ps + = case break (start ==) (linesPS ps) of + (_, _:rest@(bs1:_)) -> + case BI.toForeignPtr bs1 of + (ps1,s1,_) -> + case break (end ==) rest of + (_, bs2:_) -> case BI.toForeignPtr bs2 of (_,s2,_) -> Just $ fromForeignPtr ps1 s1 (s2 - s1) + _ -> Nothing + _ -> Nothing + +-- ------------------------------------------------------------------------- +-- break_after_nth_newline + +break_after_nth_newline :: Int -> B.ByteString + -> Maybe (B.ByteString, B.ByteString) +break_after_nth_newline 0 the_ps | B.null the_ps = Just (B.empty, B.empty) +break_after_nth_newline n the_ps = + case BI.toForeignPtr the_ps of + (fp,the_s,l) -> + unsafePerformIO $ withForeignPtr fp $ \p -> + do let findit 0 s | s == end = return $ Just (the_ps, B.empty) + findit _ s | s == end = return Nothing + findit 0 s = let left_l = s - the_s + in return $ Just (fromForeignPtr fp the_s left_l, + fromForeignPtr fp s (l - left_l)) + findit i s = do w <- peekElemOff p s + if w == nl then findit (i-1) (s+1) + else findit i (s+1) + nl = BI.c2w '\n' + end = the_s + l + findit n the_s + +-- ------------------------------------------------------------------------- +-- break_before_nth_newline + +break_before_nth_newline :: Int -> B.ByteString -> (B.ByteString, B.ByteString) +break_before_nth_newline 0 the_ps + | B.null the_ps = (B.empty, B.empty) +break_before_nth_newline n the_ps = + case BI.toForeignPtr the_ps of + (fp,the_s,l) -> + unsafePerformIO $ withForeignPtr fp $ \p -> + do let findit _ s | s == end = return (the_ps, B.empty) + findit i s = do w <- peekElemOff p s + if w == nl + then if i == 0 + then let left_l = s - the_s + in return (fromForeignPtr fp the_s left_l, + fromForeignPtr fp s (l - left_l)) + else findit (i-1) (s+1) + else findit i (s+1) + nl = BI.c2w '\n' + end = the_s + l + findit n the_s diff --git a/Test/examples/CParser.hs b/Test/examples/CParser.hs new file mode 100644 --- /dev/null +++ b/Test/examples/CParser.hs @@ -0,0 +1,6323 @@ +{-# OPTIONS -fglasgow-exts -cpp #-} +{-# LANGUAGE MagicHash #-} +module Language.C.Parser.Parser ( + -- * Parse a C translation unit + parseC, + -- * Exposed Parsers + translUnitP, extDeclP, statementP, expressionP +) where + +-- Relevant C99 sections: +-- +-- 6.5 Expressions .1 - .17 and 6.6 (almost literally) +-- Supported GNU extensions: +-- - Allow a compound statement as an expression +-- - Various __builtin_* forms that take type parameters +-- - `alignof' expression or type +-- - `__extension__' to suppress warnings about extensions +-- - Allow taking address of a label with: && label +-- - Omitting the `then' part of conditional expressions +-- - complex numbers +-- +-- 6.7 C Declarations .1 -.8 +-- Supported GNU extensions: +-- - '__thread' thread local storage (6.7.1) +-- +-- 6.8 Statements .1 - .8 +-- Supported GNU extensions: +-- - case ranges (C99 6.8.1) +-- - '__label__ ident;' declarations (C99 6.8.2) +-- - computed gotos (C99 6.8.6) +-- +-- 6.9 Translation unit +-- Supported GNU extensions: +-- - allow empty translation_unit +-- - allow redundant ';' +-- - allow extension keyword before external declaration +-- - asm definitions +-- +-- Since some of the grammar productions are quite difficult to read, +-- (especially those involved with the decleration syntax) we document them +-- with an extended syntax that allows a more consise representation: +-- +-- Ordinary rules +-- +-- foo named terminal or non-terminal +-- +-- 'c' terminal, literal character token +-- +-- A B concatenation +-- +-- A | B alternation +-- +-- (A) grouping +-- +-- Extended rules +-- +-- A? optional, short hand for (A|) or [A]{ 0==A || 1==A } +-- +-- ... stands for some part of the grammar omitted for clarity +-- +-- {A} represents sequences, 0 or more. +-- +-- modifier which states that any permutation of the immediate subterms is valid +-- +-- +--- TODO ---------------------------------------------------------------------- +-- +-- !* We ignore the C99 static keyword (see C99 6.7.5.3) +-- !* We do not distinguish in the AST between incomplete array types and +-- complete variable length arrays ([ '*' ] means the latter). (see C99 6.7.5.2) +-- !* The AST doesn't allow recording __attribute__ of unnamed struct field +-- (see , struct_default_declaring_list, struct_identifier_declarator) +-- !* see `We're being far to liberal here' (... struct definition within structs) +-- * Documentation isn't complete and consistent yet. + +import Prelude hiding (reverse) +import qualified Data.List as List +import Control.Monad (mplus) +import Language.C.Parser.Builtin (builtinTypeNames) +import Language.C.Parser.Lexer (lexC, parseError) +import Language.C.Parser.Tokens (CToken(..), GnuCTok(..), posLenOfTok) +import Language.C.Parser.ParserMonad (P, failP, execParser, getNewName, addTypedef, shadowTypedef, getCurrentPosition, + enterScope, leaveScope, getLastToken, getSavedToken, ParseError(..)) + +import Language.C.Data.RList +import Language.C.Data.InputStream +import Language.C.Data.Ident +import Language.C.Data.Name +import Language.C.Data.Node +import Language.C.Data.Position +import Language.C.Syntax +-- #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.16 + +newtype HappyAbsSyn = HappyAbsSyn (() -> ()) +happyIn7 :: (CTranslUnit) -> (HappyAbsSyn ) +happyIn7 x = unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn ) -> (CTranslUnit) +happyOut7 x = unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: (Reversed [CExtDecl]) -> (HappyAbsSyn ) +happyIn8 x = unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn ) -> (Reversed [CExtDecl]) +happyOut8 x = unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: (CExtDecl) -> (HappyAbsSyn ) +happyIn9 x = unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn ) -> (CExtDecl) +happyOut9 x = unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: (CFunDef) -> (HappyAbsSyn ) +happyIn10 x = unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn ) -> (CFunDef) +happyOut10 x = unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: (CDeclr) -> (HappyAbsSyn ) +happyIn11 x = unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn ) -> (CDeclr) +happyOut11 x = unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: (CStat) -> (HappyAbsSyn ) +happyIn12 x = unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn ) -> (CStat) +happyOut12 x = unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: (CStat) -> (HappyAbsSyn ) +happyIn13 x = unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn ) -> (CStat) +happyOut13 x = unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: (CStat) -> (HappyAbsSyn ) +happyIn14 x = unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn ) -> (CStat) +happyOut14 x = unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: (()) -> (HappyAbsSyn ) +happyIn15 x = unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn ) -> (()) +happyOut15 x = unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: (()) -> (HappyAbsSyn ) +happyIn16 x = unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn ) -> (()) +happyOut16 x = unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: (Reversed [CBlockItem]) -> (HappyAbsSyn ) +happyIn17 x = unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn ) -> (Reversed [CBlockItem]) +happyOut17 x = unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: (CBlockItem) -> (HappyAbsSyn ) +happyIn18 x = unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn ) -> (CBlockItem) +happyOut18 x = unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: (CBlockItem) -> (HappyAbsSyn ) +happyIn19 x = unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn ) -> (CBlockItem) +happyOut19 x = unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: (CFunDef) -> (HappyAbsSyn ) +happyIn20 x = unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn ) -> (CFunDef) +happyOut20 x = unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: (Reversed [Ident]) -> (HappyAbsSyn ) +happyIn21 x = unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn ) -> (Reversed [Ident]) +happyOut21 x = unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: (CStat) -> (HappyAbsSyn ) +happyIn22 x = unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn ) -> (CStat) +happyOut22 x = unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: (CStat) -> (HappyAbsSyn ) +happyIn23 x = unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn ) -> (CStat) +happyOut23 x = unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: (CStat) -> (HappyAbsSyn ) +happyIn24 x = unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn ) -> (CStat) +happyOut24 x = unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: (CStat) -> (HappyAbsSyn ) +happyIn25 x = unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn ) -> (CStat) +happyOut25 x = unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: (CAsmStmt) -> (HappyAbsSyn ) +happyIn26 x = unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn ) -> (CAsmStmt) +happyOut26 x = unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: (Maybe CTypeQual) -> (HappyAbsSyn ) +happyIn27 x = unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn ) -> (Maybe CTypeQual) +happyOut27 x = unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyIn28 :: ([CAsmOperand]) -> (HappyAbsSyn ) +happyIn28 x = unsafeCoerce# x +{-# INLINE happyIn28 #-} +happyOut28 :: (HappyAbsSyn ) -> ([CAsmOperand]) +happyOut28 x = unsafeCoerce# x +{-# INLINE happyOut28 #-} +happyIn29 :: (Reversed [CAsmOperand]) -> (HappyAbsSyn ) +happyIn29 x = unsafeCoerce# x +{-# INLINE happyIn29 #-} +happyOut29 :: (HappyAbsSyn ) -> (Reversed [CAsmOperand]) +happyOut29 x = unsafeCoerce# x +{-# INLINE happyOut29 #-} +happyIn30 :: (CAsmOperand) -> (HappyAbsSyn ) +happyIn30 x = unsafeCoerce# x +{-# INLINE happyIn30 #-} +happyOut30 :: (HappyAbsSyn ) -> (CAsmOperand) +happyOut30 x = unsafeCoerce# x +{-# INLINE happyOut30 #-} +happyIn31 :: (Reversed [CStrLit]) -> (HappyAbsSyn ) +happyIn31 x = unsafeCoerce# x +{-# INLINE happyIn31 #-} +happyOut31 :: (HappyAbsSyn ) -> (Reversed [CStrLit]) +happyOut31 x = unsafeCoerce# x +{-# INLINE happyOut31 #-} +happyIn32 :: (CDecl) -> (HappyAbsSyn ) +happyIn32 x = unsafeCoerce# x +{-# INLINE happyIn32 #-} +happyOut32 :: (HappyAbsSyn ) -> (CDecl) +happyOut32 x = unsafeCoerce# x +{-# INLINE happyOut32 #-} +happyIn33 :: (Reversed [CDecl]) -> (HappyAbsSyn ) +happyIn33 x = unsafeCoerce# x +{-# INLINE happyIn33 #-} +happyOut33 :: (HappyAbsSyn ) -> (Reversed [CDecl]) +happyOut33 x = unsafeCoerce# x +{-# INLINE happyOut33 #-} +happyIn34 :: (CDecl) -> (HappyAbsSyn ) +happyIn34 x = unsafeCoerce# x +{-# INLINE happyIn34 #-} +happyOut34 :: (HappyAbsSyn ) -> (CDecl) +happyOut34 x = unsafeCoerce# x +{-# INLINE happyOut34 #-} +happyIn35 :: ((Maybe CStrLit, [CAttr])) -> (HappyAbsSyn ) +happyIn35 x = unsafeCoerce# x +{-# INLINE happyIn35 #-} +happyOut35 :: (HappyAbsSyn ) -> ((Maybe CStrLit, [CAttr])) +happyOut35 x = unsafeCoerce# x +{-# INLINE happyOut35 #-} +happyIn36 :: (CDecl) -> (HappyAbsSyn ) +happyIn36 x = unsafeCoerce# x +{-# INLINE happyIn36 #-} +happyOut36 :: (HappyAbsSyn ) -> (CDecl) +happyOut36 x = unsafeCoerce# x +{-# INLINE happyOut36 #-} +happyIn37 :: ([CDeclSpec]) -> (HappyAbsSyn ) +happyIn37 x = unsafeCoerce# x +{-# INLINE happyIn37 #-} +happyOut37 :: (HappyAbsSyn ) -> ([CDeclSpec]) +happyOut37 x = unsafeCoerce# x +{-# INLINE happyOut37 #-} +happyIn38 :: (Reversed [CDeclSpec]) -> (HappyAbsSyn ) +happyIn38 x = unsafeCoerce# x +{-# INLINE happyIn38 #-} +happyOut38 :: (HappyAbsSyn ) -> (Reversed [CDeclSpec]) +happyOut38 x = unsafeCoerce# x +{-# INLINE happyOut38 #-} +happyIn39 :: (CDeclSpec) -> (HappyAbsSyn ) +happyIn39 x = unsafeCoerce# x +{-# INLINE happyIn39 #-} +happyOut39 :: (HappyAbsSyn ) -> (CDeclSpec) +happyOut39 x = unsafeCoerce# x +{-# INLINE happyOut39 #-} +happyIn40 :: (CStorageSpec) -> (HappyAbsSyn ) +happyIn40 x = unsafeCoerce# x +{-# INLINE happyIn40 #-} +happyOut40 :: (HappyAbsSyn ) -> (CStorageSpec) +happyOut40 x = unsafeCoerce# x +{-# INLINE happyOut40 #-} +happyIn41 :: ([CDeclSpec]) -> (HappyAbsSyn ) +happyIn41 x = unsafeCoerce# x +{-# INLINE happyIn41 #-} +happyOut41 :: (HappyAbsSyn ) -> ([CDeclSpec]) +happyOut41 x = unsafeCoerce# x +{-# INLINE happyOut41 #-} +happyIn42 :: (CTypeSpec) -> (HappyAbsSyn ) +happyIn42 x = unsafeCoerce# x +{-# INLINE happyIn42 #-} +happyOut42 :: (HappyAbsSyn ) -> (CTypeSpec) +happyOut42 x = unsafeCoerce# x +{-# INLINE happyOut42 #-} +happyIn43 :: (Reversed [CDeclSpec]) -> (HappyAbsSyn ) +happyIn43 x = unsafeCoerce# x +{-# INLINE happyIn43 #-} +happyOut43 :: (HappyAbsSyn ) -> (Reversed [CDeclSpec]) +happyOut43 x = unsafeCoerce# x +{-# INLINE happyOut43 #-} +happyIn44 :: (Reversed [CDeclSpec]) -> (HappyAbsSyn ) +happyIn44 x = unsafeCoerce# x +{-# INLINE happyIn44 #-} +happyOut44 :: (HappyAbsSyn ) -> (Reversed [CDeclSpec]) +happyOut44 x = unsafeCoerce# x +{-# INLINE happyOut44 #-} +happyIn45 :: (Reversed [CDeclSpec]) -> (HappyAbsSyn ) +happyIn45 x = unsafeCoerce# x +{-# INLINE happyIn45 #-} +happyOut45 :: (HappyAbsSyn ) -> (Reversed [CDeclSpec]) +happyOut45 x = unsafeCoerce# x +{-# INLINE happyOut45 #-} +happyIn46 :: (Reversed [CDeclSpec]) -> (HappyAbsSyn ) +happyIn46 x = unsafeCoerce# x +{-# INLINE happyIn46 #-} +happyOut46 :: (HappyAbsSyn ) -> (Reversed [CDeclSpec]) +happyOut46 x = unsafeCoerce# x +{-# INLINE happyOut46 #-} +happyIn47 :: (Reversed [CDeclSpec]) -> (HappyAbsSyn ) +happyIn47 x = unsafeCoerce# x +{-# INLINE happyIn47 #-} +happyOut47 :: (HappyAbsSyn ) -> (Reversed [CDeclSpec]) +happyOut47 x = unsafeCoerce# x +{-# INLINE happyOut47 #-} +happyIn48 :: (Reversed [CDeclSpec]) -> (HappyAbsSyn ) +happyIn48 x = unsafeCoerce# x +{-# INLINE happyIn48 #-} +happyOut48 :: (HappyAbsSyn ) -> (Reversed [CDeclSpec]) +happyOut48 x = unsafeCoerce# x +{-# INLINE happyOut48 #-} +happyIn49 :: (CTypeSpec) -> (HappyAbsSyn ) +happyIn49 x = unsafeCoerce# x +{-# INLINE happyIn49 #-} +happyOut49 :: (HappyAbsSyn ) -> (CTypeSpec) +happyOut49 x = unsafeCoerce# x +{-# INLINE happyOut49 #-} +happyIn50 :: (CStructUnion) -> (HappyAbsSyn ) +happyIn50 x = unsafeCoerce# x +{-# INLINE happyIn50 #-} +happyOut50 :: (HappyAbsSyn ) -> (CStructUnion) +happyOut50 x = unsafeCoerce# x +{-# INLINE happyOut50 #-} +happyIn51 :: (Located CStructTag) -> (HappyAbsSyn ) +happyIn51 x = unsafeCoerce# x +{-# INLINE happyIn51 #-} +happyOut51 :: (HappyAbsSyn ) -> (Located CStructTag) +happyOut51 x = unsafeCoerce# x +{-# INLINE happyOut51 #-} +happyIn52 :: (Reversed [CDecl]) -> (HappyAbsSyn ) +happyIn52 x = unsafeCoerce# x +{-# INLINE happyIn52 #-} +happyOut52 :: (HappyAbsSyn ) -> (Reversed [CDecl]) +happyOut52 x = unsafeCoerce# x +{-# INLINE happyOut52 #-} +happyIn53 :: (CDecl) -> (HappyAbsSyn ) +happyIn53 x = unsafeCoerce# x +{-# INLINE happyIn53 #-} +happyOut53 :: (HappyAbsSyn ) -> (CDecl) +happyOut53 x = unsafeCoerce# x +{-# INLINE happyOut53 #-} +happyIn54 :: (CDecl) -> (HappyAbsSyn ) +happyIn54 x = unsafeCoerce# x +{-# INLINE happyIn54 #-} +happyOut54 :: (HappyAbsSyn ) -> (CDecl) +happyOut54 x = unsafeCoerce# x +{-# INLINE happyOut54 #-} +happyIn55 :: (CDecl) -> (HappyAbsSyn ) +happyIn55 x = unsafeCoerce# x +{-# INLINE happyIn55 #-} +happyOut55 :: (HappyAbsSyn ) -> (CDecl) +happyOut55 x = unsafeCoerce# x +{-# INLINE happyOut55 #-} +happyIn56 :: ((Maybe CDeclr, Maybe CExpr)) -> (HappyAbsSyn ) +happyIn56 x = unsafeCoerce# x +{-# INLINE happyIn56 #-} +happyOut56 :: (HappyAbsSyn ) -> ((Maybe CDeclr, Maybe CExpr)) +happyOut56 x = unsafeCoerce# x +{-# INLINE happyOut56 #-} +happyIn57 :: ((Maybe CDeclr, Maybe CExpr)) -> (HappyAbsSyn ) +happyIn57 x = unsafeCoerce# x +{-# INLINE happyIn57 #-} +happyOut57 :: (HappyAbsSyn ) -> ((Maybe CDeclr, Maybe CExpr)) +happyOut57 x = unsafeCoerce# x +{-# INLINE happyOut57 #-} +happyIn58 :: (CEnum) -> (HappyAbsSyn ) +happyIn58 x = unsafeCoerce# x +{-# INLINE happyIn58 #-} +happyOut58 :: (HappyAbsSyn ) -> (CEnum) +happyOut58 x = unsafeCoerce# x +{-# INLINE happyOut58 #-} +happyIn59 :: (Reversed [(Ident, Maybe CExpr)]) -> (HappyAbsSyn ) +happyIn59 x = unsafeCoerce# x +{-# INLINE happyIn59 #-} +happyOut59 :: (HappyAbsSyn ) -> (Reversed [(Ident, Maybe CExpr)]) +happyOut59 x = unsafeCoerce# x +{-# INLINE happyOut59 #-} +happyIn60 :: ((Ident, Maybe CExpr)) -> (HappyAbsSyn ) +happyIn60 x = unsafeCoerce# x +{-# INLINE happyIn60 #-} +happyOut60 :: (HappyAbsSyn ) -> ((Ident, Maybe CExpr)) +happyOut60 x = unsafeCoerce# x +{-# INLINE happyOut60 #-} +happyIn61 :: (CTypeQual) -> (HappyAbsSyn ) +happyIn61 x = unsafeCoerce# x +{-# INLINE happyIn61 #-} +happyOut61 :: (HappyAbsSyn ) -> (CTypeQual) +happyOut61 x = unsafeCoerce# x +{-# INLINE happyOut61 #-} +happyIn62 :: (Reversed [CTypeQual]) -> (HappyAbsSyn ) +happyIn62 x = unsafeCoerce# x +{-# INLINE happyIn62 #-} +happyOut62 :: (HappyAbsSyn ) -> (Reversed [CTypeQual]) +happyOut62 x = unsafeCoerce# x +{-# INLINE happyOut62 #-} +happyIn63 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn63 x = unsafeCoerce# x +{-# INLINE happyIn63 #-} +happyOut63 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut63 x = unsafeCoerce# x +{-# INLINE happyOut63 #-} +happyIn64 :: (Maybe CStrLit) -> (HappyAbsSyn ) +happyIn64 x = unsafeCoerce# x +{-# INLINE happyIn64 #-} +happyOut64 :: (HappyAbsSyn ) -> (Maybe CStrLit) +happyOut64 x = unsafeCoerce# x +{-# INLINE happyOut64 #-} +happyIn65 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn65 x = unsafeCoerce# x +{-# INLINE happyIn65 #-} +happyOut65 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut65 x = unsafeCoerce# x +{-# INLINE happyOut65 #-} +happyIn66 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn66 x = unsafeCoerce# x +{-# INLINE happyIn66 #-} +happyOut66 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut66 x = unsafeCoerce# x +{-# INLINE happyOut66 #-} +happyIn67 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn67 x = unsafeCoerce# x +{-# INLINE happyIn67 #-} +happyOut67 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut67 x = unsafeCoerce# x +{-# INLINE happyOut67 #-} +happyIn68 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn68 x = unsafeCoerce# x +{-# INLINE happyIn68 #-} +happyOut68 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut68 x = unsafeCoerce# x +{-# INLINE happyOut68 #-} +happyIn69 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn69 x = unsafeCoerce# x +{-# INLINE happyIn69 #-} +happyOut69 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut69 x = unsafeCoerce# x +{-# INLINE happyOut69 #-} +happyIn70 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn70 x = unsafeCoerce# x +{-# INLINE happyIn70 #-} +happyOut70 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut70 x = unsafeCoerce# x +{-# INLINE happyOut70 #-} +happyIn71 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn71 x = unsafeCoerce# x +{-# INLINE happyIn71 #-} +happyOut71 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut71 x = unsafeCoerce# x +{-# INLINE happyOut71 #-} +happyIn72 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn72 x = unsafeCoerce# x +{-# INLINE happyIn72 #-} +happyOut72 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut72 x = unsafeCoerce# x +{-# INLINE happyOut72 #-} +happyIn73 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn73 x = unsafeCoerce# x +{-# INLINE happyIn73 #-} +happyOut73 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut73 x = unsafeCoerce# x +{-# INLINE happyOut73 #-} +happyIn74 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn74 x = unsafeCoerce# x +{-# INLINE happyIn74 #-} +happyOut74 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut74 x = unsafeCoerce# x +{-# INLINE happyOut74 #-} +happyIn75 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn75 x = unsafeCoerce# x +{-# INLINE happyIn75 #-} +happyOut75 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut75 x = unsafeCoerce# x +{-# INLINE happyOut75 #-} +happyIn76 :: (CDeclr) -> (HappyAbsSyn ) +happyIn76 x = unsafeCoerce# x +{-# INLINE happyIn76 #-} +happyOut76 :: (HappyAbsSyn ) -> (CDeclr) +happyOut76 x = unsafeCoerce# x +{-# INLINE happyOut76 #-} +happyIn77 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn77 x = unsafeCoerce# x +{-# INLINE happyIn77 #-} +happyOut77 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut77 x = unsafeCoerce# x +{-# INLINE happyOut77 #-} +happyIn78 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn78 x = unsafeCoerce# x +{-# INLINE happyIn78 #-} +happyOut78 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut78 x = unsafeCoerce# x +{-# INLINE happyOut78 #-} +happyIn79 :: (([CDecl], Bool)) -> (HappyAbsSyn ) +happyIn79 x = unsafeCoerce# x +{-# INLINE happyIn79 #-} +happyOut79 :: (HappyAbsSyn ) -> (([CDecl], Bool)) +happyOut79 x = unsafeCoerce# x +{-# INLINE happyOut79 #-} +happyIn80 :: (Reversed [CDecl]) -> (HappyAbsSyn ) +happyIn80 x = unsafeCoerce# x +{-# INLINE happyIn80 #-} +happyOut80 :: (HappyAbsSyn ) -> (Reversed [CDecl]) +happyOut80 x = unsafeCoerce# x +{-# INLINE happyOut80 #-} +happyIn81 :: (CDecl) -> (HappyAbsSyn ) +happyIn81 x = unsafeCoerce# x +{-# INLINE happyIn81 #-} +happyOut81 :: (HappyAbsSyn ) -> (CDecl) +happyOut81 x = unsafeCoerce# x +{-# INLINE happyOut81 #-} +happyIn82 :: (Reversed [Ident]) -> (HappyAbsSyn ) +happyIn82 x = unsafeCoerce# x +{-# INLINE happyIn82 #-} +happyOut82 :: (HappyAbsSyn ) -> (Reversed [Ident]) +happyOut82 x = unsafeCoerce# x +{-# INLINE happyOut82 #-} +happyIn83 :: (CDecl) -> (HappyAbsSyn ) +happyIn83 x = unsafeCoerce# x +{-# INLINE happyIn83 #-} +happyOut83 :: (HappyAbsSyn ) -> (CDecl) +happyOut83 x = unsafeCoerce# x +{-# INLINE happyOut83 #-} +happyIn84 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn84 x = unsafeCoerce# x +{-# INLINE happyIn84 #-} +happyOut84 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut84 x = unsafeCoerce# x +{-# INLINE happyOut84 #-} +happyIn85 :: (CDeclrR -> CDeclrR) -> (HappyAbsSyn ) +happyIn85 x = unsafeCoerce# x +{-# INLINE happyIn85 #-} +happyOut85 :: (HappyAbsSyn ) -> (CDeclrR -> CDeclrR) +happyOut85 x = unsafeCoerce# x +{-# INLINE happyOut85 #-} +happyIn86 :: (CDeclrR -> CDeclrR) -> (HappyAbsSyn ) +happyIn86 x = unsafeCoerce# x +{-# INLINE happyIn86 #-} +happyOut86 :: (HappyAbsSyn ) -> (CDeclrR -> CDeclrR) +happyOut86 x = unsafeCoerce# x +{-# INLINE happyOut86 #-} +happyIn87 :: (CDeclrR -> CDeclrR) -> (HappyAbsSyn ) +happyIn87 x = unsafeCoerce# x +{-# INLINE happyIn87 #-} +happyOut87 :: (HappyAbsSyn ) -> (CDeclrR -> CDeclrR) +happyOut87 x = unsafeCoerce# x +{-# INLINE happyOut87 #-} +happyIn88 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn88 x = unsafeCoerce# x +{-# INLINE happyIn88 #-} +happyOut88 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut88 x = unsafeCoerce# x +{-# INLINE happyOut88 #-} +happyIn89 :: (CDeclrR) -> (HappyAbsSyn ) +happyIn89 x = unsafeCoerce# x +{-# INLINE happyIn89 #-} +happyOut89 :: (HappyAbsSyn ) -> (CDeclrR) +happyOut89 x = unsafeCoerce# x +{-# INLINE happyOut89 #-} +happyIn90 :: (CInit) -> (HappyAbsSyn ) +happyIn90 x = unsafeCoerce# x +{-# INLINE happyIn90 #-} +happyOut90 :: (HappyAbsSyn ) -> (CInit) +happyOut90 x = unsafeCoerce# x +{-# INLINE happyOut90 #-} +happyIn91 :: (Maybe CInit) -> (HappyAbsSyn ) +happyIn91 x = unsafeCoerce# x +{-# INLINE happyIn91 #-} +happyOut91 :: (HappyAbsSyn ) -> (Maybe CInit) +happyOut91 x = unsafeCoerce# x +{-# INLINE happyOut91 #-} +happyIn92 :: (Reversed CInitList) -> (HappyAbsSyn ) +happyIn92 x = unsafeCoerce# x +{-# INLINE happyIn92 #-} +happyOut92 :: (HappyAbsSyn ) -> (Reversed CInitList) +happyOut92 x = unsafeCoerce# x +{-# INLINE happyOut92 #-} +happyIn93 :: ([CDesignator]) -> (HappyAbsSyn ) +happyIn93 x = unsafeCoerce# x +{-# INLINE happyIn93 #-} +happyOut93 :: (HappyAbsSyn ) -> ([CDesignator]) +happyOut93 x = unsafeCoerce# x +{-# INLINE happyOut93 #-} +happyIn94 :: (Reversed [CDesignator]) -> (HappyAbsSyn ) +happyIn94 x = unsafeCoerce# x +{-# INLINE happyIn94 #-} +happyOut94 :: (HappyAbsSyn ) -> (Reversed [CDesignator]) +happyOut94 x = unsafeCoerce# x +{-# INLINE happyOut94 #-} +happyIn95 :: (CDesignator) -> (HappyAbsSyn ) +happyIn95 x = unsafeCoerce# x +{-# INLINE happyIn95 #-} +happyOut95 :: (HappyAbsSyn ) -> (CDesignator) +happyOut95 x = unsafeCoerce# x +{-# INLINE happyOut95 #-} +happyIn96 :: (CDesignator) -> (HappyAbsSyn ) +happyIn96 x = unsafeCoerce# x +{-# INLINE happyIn96 #-} +happyOut96 :: (HappyAbsSyn ) -> (CDesignator) +happyOut96 x = unsafeCoerce# x +{-# INLINE happyOut96 #-} +happyIn97 :: (CExpr) -> (HappyAbsSyn ) +happyIn97 x = unsafeCoerce# x +{-# INLINE happyIn97 #-} +happyOut97 :: (HappyAbsSyn ) -> (CExpr) +happyOut97 x = unsafeCoerce# x +{-# INLINE happyOut97 #-} +happyIn98 :: (Reversed [CDesignator]) -> (HappyAbsSyn ) +happyIn98 x = unsafeCoerce# x +{-# INLINE happyIn98 #-} +happyOut98 :: (HappyAbsSyn ) -> (Reversed [CDesignator]) +happyOut98 x = unsafeCoerce# x +{-# INLINE happyOut98 #-} +happyIn99 :: (CExpr) -> (HappyAbsSyn ) +happyIn99 x = unsafeCoerce# x +{-# INLINE happyIn99 #-} +happyOut99 :: (HappyAbsSyn ) -> (CExpr) +happyOut99 x = unsafeCoerce# x +{-# INLINE happyOut99 #-} +happyIn100 :: (Reversed [CExpr]) -> (HappyAbsSyn ) +happyIn100 x = unsafeCoerce# x +{-# INLINE happyIn100 #-} +happyOut100 :: (HappyAbsSyn ) -> (Reversed [CExpr]) +happyOut100 x = unsafeCoerce# x +{-# INLINE happyOut100 #-} +happyIn101 :: (CExpr) -> (HappyAbsSyn ) +happyIn101 x = unsafeCoerce# x +{-# INLINE happyIn101 #-} +happyOut101 :: (HappyAbsSyn ) -> (CExpr) +happyOut101 x = unsafeCoerce# x +{-# INLINE happyOut101 #-} +happyIn102 :: (Located CUnaryOp) -> (HappyAbsSyn ) +happyIn102 x = unsafeCoerce# x +{-# INLINE happyIn102 #-} +happyOut102 :: (HappyAbsSyn ) -> (Located CUnaryOp) +happyOut102 x = unsafeCoerce# x +{-# INLINE happyOut102 #-} +happyIn103 :: (CExpr) -> (HappyAbsSyn ) +happyIn103 x = unsafeCoerce# x +{-# INLINE happyIn103 #-} +happyOut103 :: (HappyAbsSyn ) -> (CExpr) +happyOut103 x = unsafeCoerce# x +{-# INLINE happyOut103 #-} +happyIn104 :: (CExpr) -> (HappyAbsSyn ) +happyIn104 x = unsafeCoerce# x +{-# INLINE happyIn104 #-} +happyOut104 :: (HappyAbsSyn ) -> (CExpr) +happyOut104 x = unsafeCoerce# x +{-# INLINE happyOut104 #-} +happyIn105 :: (CExpr) -> (HappyAbsSyn ) +happyIn105 x = unsafeCoerce# x +{-# INLINE happyIn105 #-} +happyOut105 :: (HappyAbsSyn ) -> (CExpr) +happyOut105 x = unsafeCoerce# x +{-# INLINE happyOut105 #-} +happyIn106 :: (CExpr) -> (HappyAbsSyn ) +happyIn106 x = unsafeCoerce# x +{-# INLINE happyIn106 #-} +happyOut106 :: (HappyAbsSyn ) -> (CExpr) +happyOut106 x = unsafeCoerce# x +{-# INLINE happyOut106 #-} +happyIn107 :: (CExpr) -> (HappyAbsSyn ) +happyIn107 x = unsafeCoerce# x +{-# INLINE happyIn107 #-} +happyOut107 :: (HappyAbsSyn ) -> (CExpr) +happyOut107 x = unsafeCoerce# x +{-# INLINE happyOut107 #-} +happyIn108 :: (CExpr) -> (HappyAbsSyn ) +happyIn108 x = unsafeCoerce# x +{-# INLINE happyIn108 #-} +happyOut108 :: (HappyAbsSyn ) -> (CExpr) +happyOut108 x = unsafeCoerce# x +{-# INLINE happyOut108 #-} +happyIn109 :: (CExpr) -> (HappyAbsSyn ) +happyIn109 x = unsafeCoerce# x +{-# INLINE happyIn109 #-} +happyOut109 :: (HappyAbsSyn ) -> (CExpr) +happyOut109 x = unsafeCoerce# x +{-# INLINE happyOut109 #-} +happyIn110 :: (CExpr) -> (HappyAbsSyn ) +happyIn110 x = unsafeCoerce# x +{-# INLINE happyIn110 #-} +happyOut110 :: (HappyAbsSyn ) -> (CExpr) +happyOut110 x = unsafeCoerce# x +{-# INLINE happyOut110 #-} +happyIn111 :: (CExpr) -> (HappyAbsSyn ) +happyIn111 x = unsafeCoerce# x +{-# INLINE happyIn111 #-} +happyOut111 :: (HappyAbsSyn ) -> (CExpr) +happyOut111 x = unsafeCoerce# x +{-# INLINE happyOut111 #-} +happyIn112 :: (CExpr) -> (HappyAbsSyn ) +happyIn112 x = unsafeCoerce# x +{-# INLINE happyIn112 #-} +happyOut112 :: (HappyAbsSyn ) -> (CExpr) +happyOut112 x = unsafeCoerce# x +{-# INLINE happyOut112 #-} +happyIn113 :: (CExpr) -> (HappyAbsSyn ) +happyIn113 x = unsafeCoerce# x +{-# INLINE happyIn113 #-} +happyOut113 :: (HappyAbsSyn ) -> (CExpr) +happyOut113 x = unsafeCoerce# x +{-# INLINE happyOut113 #-} +happyIn114 :: (CExpr) -> (HappyAbsSyn ) +happyIn114 x = unsafeCoerce# x +{-# INLINE happyIn114 #-} +happyOut114 :: (HappyAbsSyn ) -> (CExpr) +happyOut114 x = unsafeCoerce# x +{-# INLINE happyOut114 #-} +happyIn115 :: (CExpr) -> (HappyAbsSyn ) +happyIn115 x = unsafeCoerce# x +{-# INLINE happyIn115 #-} +happyOut115 :: (HappyAbsSyn ) -> (CExpr) +happyOut115 x = unsafeCoerce# x +{-# INLINE happyOut115 #-} +happyIn116 :: (Located CAssignOp) -> (HappyAbsSyn ) +happyIn116 x = unsafeCoerce# x +{-# INLINE happyIn116 #-} +happyOut116 :: (HappyAbsSyn ) -> (Located CAssignOp) +happyOut116 x = unsafeCoerce# x +{-# INLINE happyOut116 #-} +happyIn117 :: (CExpr) -> (HappyAbsSyn ) +happyIn117 x = unsafeCoerce# x +{-# INLINE happyIn117 #-} +happyOut117 :: (HappyAbsSyn ) -> (CExpr) +happyOut117 x = unsafeCoerce# x +{-# INLINE happyOut117 #-} +happyIn118 :: (Reversed [CExpr]) -> (HappyAbsSyn ) +happyIn118 x = unsafeCoerce# x +{-# INLINE happyIn118 #-} +happyOut118 :: (HappyAbsSyn ) -> (Reversed [CExpr]) +happyOut118 x = unsafeCoerce# x +{-# INLINE happyOut118 #-} +happyIn119 :: (Maybe CExpr) -> (HappyAbsSyn ) +happyIn119 x = unsafeCoerce# x +{-# INLINE happyIn119 #-} +happyOut119 :: (HappyAbsSyn ) -> (Maybe CExpr) +happyOut119 x = unsafeCoerce# x +{-# INLINE happyOut119 #-} +happyIn120 :: (Maybe CExpr) -> (HappyAbsSyn ) +happyIn120 x = unsafeCoerce# x +{-# INLINE happyIn120 #-} +happyOut120 :: (HappyAbsSyn ) -> (Maybe CExpr) +happyOut120 x = unsafeCoerce# x +{-# INLINE happyOut120 #-} +happyIn121 :: (CExpr) -> (HappyAbsSyn ) +happyIn121 x = unsafeCoerce# x +{-# INLINE happyIn121 #-} +happyOut121 :: (HappyAbsSyn ) -> (CExpr) +happyOut121 x = unsafeCoerce# x +{-# INLINE happyOut121 #-} +happyIn122 :: (CConst) -> (HappyAbsSyn ) +happyIn122 x = unsafeCoerce# x +{-# INLINE happyIn122 #-} +happyOut122 :: (HappyAbsSyn ) -> (CConst) +happyOut122 x = unsafeCoerce# x +{-# INLINE happyOut122 #-} +happyIn123 :: (CStrLit) -> (HappyAbsSyn ) +happyIn123 x = unsafeCoerce# x +{-# INLINE happyIn123 #-} +happyOut123 :: (HappyAbsSyn ) -> (CStrLit) +happyOut123 x = unsafeCoerce# x +{-# INLINE happyOut123 #-} +happyIn124 :: (Reversed [CString]) -> (HappyAbsSyn ) +happyIn124 x = unsafeCoerce# x +{-# INLINE happyIn124 #-} +happyOut124 :: (HappyAbsSyn ) -> (Reversed [CString]) +happyOut124 x = unsafeCoerce# x +{-# INLINE happyOut124 #-} +happyIn125 :: (Ident) -> (HappyAbsSyn ) +happyIn125 x = unsafeCoerce# x +{-# INLINE happyIn125 #-} +happyOut125 :: (HappyAbsSyn ) -> (Ident) +happyOut125 x = unsafeCoerce# x +{-# INLINE happyOut125 #-} +happyIn126 :: ([CAttr]) -> (HappyAbsSyn ) +happyIn126 x = unsafeCoerce# x +{-# INLINE happyIn126 #-} +happyOut126 :: (HappyAbsSyn ) -> ([CAttr]) +happyOut126 x = unsafeCoerce# x +{-# INLINE happyOut126 #-} +happyIn127 :: ([CAttr]) -> (HappyAbsSyn ) +happyIn127 x = unsafeCoerce# x +{-# INLINE happyIn127 #-} +happyOut127 :: (HappyAbsSyn ) -> ([CAttr]) +happyOut127 x = unsafeCoerce# x +{-# INLINE happyOut127 #-} +happyIn128 :: ([CAttr]) -> (HappyAbsSyn ) +happyIn128 x = unsafeCoerce# x +{-# INLINE happyIn128 #-} +happyOut128 :: (HappyAbsSyn ) -> ([CAttr]) +happyOut128 x = unsafeCoerce# x +{-# INLINE happyOut128 #-} +happyIn129 :: (Reversed [CAttr]) -> (HappyAbsSyn ) +happyIn129 x = unsafeCoerce# x +{-# INLINE happyIn129 #-} +happyOut129 :: (HappyAbsSyn ) -> (Reversed [CAttr]) +happyOut129 x = unsafeCoerce# x +{-# INLINE happyOut129 #-} +happyIn130 :: (Maybe CAttr) -> (HappyAbsSyn ) +happyIn130 x = unsafeCoerce# x +{-# INLINE happyIn130 #-} +happyOut130 :: (HappyAbsSyn ) -> (Maybe CAttr) +happyOut130 x = unsafeCoerce# x +{-# INLINE happyOut130 #-} +happyIn131 :: (Reversed [CExpr]) -> (HappyAbsSyn ) +happyIn131 x = unsafeCoerce# x +{-# INLINE happyIn131 #-} +happyOut131 :: (HappyAbsSyn ) -> (Reversed [CExpr]) +happyOut131 x = unsafeCoerce# x +{-# INLINE happyOut131 #-} +happyInTok :: CToken -> (HappyAbsSyn ) +happyInTok x = unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn ) -> CToken +happyOutTok x = unsafeCoerce# x +{-# INLINE happyOutTok #-} + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\x00\x00\x1d\x0f\xd3\x09\x31\x0f\x00\x00\x80\x07\x00\x00\x7f\x09\x77\x0f\x31\x0f\x00\x00\xc8\x09\x1f\x05\x05\x05\x7f\x03\xf0\x04\x65\x08\x54\x08\x49\x08\x3e\x08\xc6\x04\x00\x00\x2b\x08\xef\x07\x00\x00\x00\x00\x0b\x09\x00\x00\x00\x00\xcd\x0e\xcd\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x82\x04\xaf\x0e\x96\x0e\x00\x00\x00\x00\x00\x00\xf6\x07\x00\x00\x32\x0e\x14\x0e\x14\x0e\x48\x08\x47\x08\x24\x08\xb6\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x07\xe6\x07\x00\x00\x00\x00\x4a\x05\xd2\x07\xfb\x0d\xd0\x07\xd6\x07\xd3\x09\xf5\x07\x24\x00\xed\x07\xfb\x0d\xec\x07\xd5\x07\xc6\x07\x00\x00\x76\x07\x00\x00\xae\x07\x00\x00\x95\x04\x8e\x04\x01\x01\xd5\x11\x00\x00\x01\x01\x00\x00\x9a\x19\x9a\x19\x11\x18\x01\x18\x21\x08\x21\x08\x00\x00\x00\x00\x71\x07\x00\x00\xa6\x11\x00\x00\x00\x00\x00\x00\xd9\x01\x00\x00\x00\x00\x00\x00\x4a\x05\x89\x12\x00\x00\x3d\x01\x3d\x01\xcb\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x07\x1d\x0f\x55\x07\x00\x00\xb8\x07\x6f\x09\x7a\x01\x59\x07\x5b\x07\xb3\x12\x00\x00\x00\x00\x4b\x00\xb2\x07\xb4\x09\xaa\x07\x4b\x00\x86\x07\x00\x00\x00\x00\x00\x00\xed\x01\x00\x00\x00\x00\xa7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x18\x00\x00\x9d\x07\x00\x00\x94\x18\xff\x0a\x72\x07\x00\x00\x00\x00\x00\x00\x00\x00\xed\x01\x00\x00\x77\x11\x97\x07\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x07\x5f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x07\x00\x00\x6e\x02\x48\x02\x0f\x00\x52\x07\x00\x00\x00\x00\x00\x00\xed\x01\x00\x00\x00\x00\x7b\x07\x00\x00\x4f\x07\x53\x07\x00\x00\x1b\x07\x00\x00\x1b\x07\x00\x00\x00\x00\xfb\x0d\xfb\x0d\x00\x00\x4d\x07\xfb\x0d\x41\x07\xfb\x0d\x00\x00\x43\x08\x14\x07\xd3\x09\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x65\x07\x00\x00\x2e\x07\xf4\x06\x00\x00\xc3\x1a\xc3\x1a\xfb\x0d\x00\x00\x0b\x09\x00\x00\x00\x00\xf0\x06\x00\x00\x00\x00\x0b\x09\x00\x00\x0b\x09\x00\x00\x00\x00\x00\x00\x4e\x07\x97\x03\xe7\x1a\xab\x04\xab\x04\x7a\x0a\x4c\x07\x4b\x07\x9f\x1a\xfb\x0d\xfb\x0d\x97\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\xfb\x0d\x00\x00\xfb\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x0d\xfb\x0d\x36\x04\x36\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x07\x6e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x09\xa3\x09\x8a\x04\x8a\x04\x4f\x04\x4f\x04\x4f\x04\x4f\x04\x7f\x03\x7f\x03\x1d\x04\x35\x07\x2b\x07\x16\x07\x0c\x07\xfb\x0d\x25\x07\x00\x00\xfb\x06\x00\x00\x61\x0d\x00\x00\x00\x00\x00\x00\xb7\x06\x57\x1a\x33\x1a\x48\x11\x00\x0f\x00\x00\x00\x00\x0f\x07\x0e\x07\x00\x00\xf3\x06\xdd\x06\xdb\x06\xc7\x06\xd3\x09\xdf\x07\xad\x06\x94\x06\x7c\x06\xd3\x09\xfb\x0d\x00\x00\xcb\x06\x6c\x19\xab\x06\xa7\x06\x00\x00\xc4\x06\x00\x00\xc3\x06\xc1\x06\xea\x00\xd8\x00\x38\x18\xa1\x06\x5d\x06\xaa\x06\x00\x00\x6f\x09\x38\x18\x86\x06\x00\x00\x00\x00\x1e\x19\x5b\x0b\x00\x00\x00\x00\xb1\x01\x93\x01\x8e\x06\x88\x06\x0f\x00\x47\x00\x93\x01\x00\x00\x38\x18\x66\x06\x00\x00\x49\x06\x00\x00\x6f\x09\x3e\x06\x00\x00\x00\x00\x00\x00\x00\x00\xed\x01\x00\x00\x62\x06\x00\x00\x38\x18\x3d\x06\x00\x00\x9b\x0a\x00\x00\x29\x06\xe0\x0b\x09\x00\xce\x05\x74\x02\xff\x0f\x74\x02\x21\x08\x21\x08\xd0\x0f\x24\x06\xfb\x05\x00\x00\x1b\x01\x45\x19\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x19\x11\xd8\x00\xea\x10\x5a\x12\x6f\x09\x38\x18\x04\x06\x00\x00\x19\x06\x9e\x09\x12\x00\x12\x00\x0f\x00\x00\x00\x0f\x00\x00\x00\x0f\x00\x00\x00\x00\x00\xdc\x0c\x09\x06\xf4\x05\xcc\x03\x03\x06\xfe\x05\x77\x00\xca\x00\x00\x00\x00\x00\xef\x05\x00\x00\x00\x00\xcd\x02\x00\x00\xcb\x05\xcc\x03\xaa\x05\x00\x00\x00\x00\x00\x00\xdc\x0c\x4b\x09\x00\x00\x0f\x00\x00\x00\xfd\x0c\x00\x00\xc8\x05\xc1\x05\x8c\x05\x8c\x05\xbb\x10\x00\x00\xf1\x00\xc9\x00\x8c\x05\x00\x00\x56\x05\x66\x18\x00\x00\x53\x05\x00\x00\xf0\x18\xc2\x18\xa1\x0f\xde\x12\x53\x05\x53\x05\x00\x00\x72\x0f\x49\x07\x53\x05\x00\x00\x53\x05\x53\x05\x00\x00\xab\x04\x62\x0c\x9d\x05\x9b\x05\x09\x00\x00\x00\x90\x05\x46\x05\x37\x0a\x09\x00\x00\x00\x00\x00\x6f\x09\x38\x18\x6d\x05\x00\x00\x8f\x05\x8d\x05\xdc\x17\x00\x00\x00\x00\x00\x00\x2f\x09\x84\x05\x0e\x00\xbe\x00\x83\x05\x0f\x00\x0f\x00\x2c\x09\x00\x00\x00\x00\x00\x00\xe3\x0a\x65\x00\x00\x00\x00\x00\x81\x05\x79\x05\x10\x05\x00\x00\x00\x00\x00\x00\x35\x05\x35\x05\xd3\x09\xd3\x09\xd3\x09\x00\x00\xfb\x0d\xfb\x0d\xfb\x0d\x42\x05\x00\x00\xaa\x01\xc9\x03\xdf\x07\xf2\x04\x00\x00\x23\x05\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x8c\x10\xd8\x00\x5d\x10\x2d\x05\xa7\x08\x00\x00\x7b\x1a\x9a\x03\x7b\x1a\x1c\x05\x1c\x05\x1c\x05\x30\x0c\x00\x00\xa2\x09\x31\x05\x2f\x05\x2d\x00\x33\x12\x00\x00\x00\x00\xfe\x0b\xfb\x0d\x00\x00\xfb\x0d\x00\x00\xfb\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x02\xfd\x0c\xdc\x02\x00\x00\x99\x01\x00\x00\xd4\x04\xfb\x0d\x9a\x03\xfe\x0b\x21\x05\x0d\x05\x13\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x04\x09\x05\xed\x02\x00\x00\xf9\x04\x00\x00\xc0\x04\x2e\x10\xc0\x04\xc0\x04\xc0\x04\x00\x00\xa3\x03\x89\x04\x00\x00\xa2\x04\x2a\x00\xd3\x09\xc7\x04\x9c\x04\x97\x04\x7f\x04\x00\x00\x00\x00\x88\x04\x88\x04\xa1\x04\x00\x00\x00\x00\x22\x09\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x0a\x0f\x00\x00\x00\xaf\x17\xd4\x02\x00\x00\xa0\x03\x98\x03\x0f\x1a\xc2\x12\x00\x00\x00\x00\xbe\x19\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x04\x9a\x04\x8b\x04\x86\x04\x09\x00\x0a\x04\x00\x00\x7a\x04\x00\x00\x00\x00\x68\x04\xfb\x0d\x00\x00\x00\x00\x00\x00\xb4\x04\x9f\x00\x04\x12\x00\x00\x00\x00\xdc\x0a\x3e\x09\x24\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x01\x2b\x00\x2b\x00\x16\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x02\xfb\x0d\xf4\x00\x00\x00\xe4\x0c\x64\x04\x77\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x2b\x00\x5f\x01\xcd\x00\x3e\x04\x00\x00\x00\x00\xfb\x0d\x3c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x03\x1b\x04\xfb\x0d\x9e\x00\xeb\x19\xc8\x03\x00\x00\xc8\x03\x00\x00\xc8\x03\x06\x04\xfb\x0d\x00\x00\x00\x00\xcd\x00\x1f\x09\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x09\xfb\x0d\xfb\x0d\xf5\x03\x00\x00\x0a\x01\xef\x03\x00\x00\x1a\x04\x49\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x03\x00\x00\x00\x00\x00\x00\xfb\x0d\x40\x03\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x97\x01\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x0b\x00\x00\x00\x00\x80\x0c\x00\x00\x00\x00\xfb\x0d\x63\x0b\x00\x00\x00\x00\x00\x00\x03\x04\x00\x00\x01\x04\xe1\x03\xfb\x0d\x2a\x00\xb6\x03\x2a\x00\x00\x00\xd8\x03\xd3\x03\x00\x00\x00\x00\x00\x00\xfb\x0d\x00\x00\x9e\x00\xd4\x02\x6a\x03\x00\x00\xfb\x0d\x00\x00\x00\x00\xb9\x03\x00\x00\x00\x00\x00\x00\xfb\x0d\x00\x00\x00\x00\x00\x00\x4a\x03\x4a\x03\x00\x00\xd3\x09\xd3\x09\xd5\x00\x00\x00\x00\x00\xa8\x03\x3b\x03\x3b\x03\x00\x00\x00\x00\x7a\x03\x00\x00\x00\x00\x74\x03\x72\x03\x00\x00\x46\x03\x0b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\xfb\x0d\xfb\x0d\x6c\x03\x5b\x03\x17\x03\xe9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x36\x03\x71\x00\xd3\x06\xc6\x1d\x3c\x03\x38\x00\x00\x00\x00\x00\xc5\x02\x35\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x03\x00\x00\x00\x00\x71\x0d\xa4\x0b\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x02\xd5\x0a\xb9\x0a\x00\x00\x00\x00\x00\x00\xa7\x02\x00\x00\x20\x0c\xbe\x03\x60\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x1a\x00\x00\x00\x76\x1f\x00\x00\x00\x00\xb8\x06\x00\x00\x95\x02\x00\x00\x4c\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x03\x00\x00\x00\x00\x00\x00\x2a\x06\xc3\x00\x00\x00\x8a\x05\x00\x00\x14\x00\x16\x01\x6c\x02\x7d\x01\xa2\x01\xcb\x00\x00\x00\x00\x00\x96\x08\x00\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x99\x08\xe2\x02\x00\x00\x00\x00\xbb\x02\x15\x01\x00\x00\xa8\x0a\xd7\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\xca\x15\x71\x02\x5d\x02\x6a\x02\x77\x08\x00\x00\x00\x00\x70\x02\x00\x00\x5b\x08\x00\x00\x40\x00\xc6\x02\x00\x00\x00\x00\x00\x00\x52\x02\x9e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x04\x00\x00\x66\x02\x00\x00\xa8\x13\x16\x17\xa9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x51\x02\x90\x02\xec\x00\x00\x00\x00\x00\x1a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x02\x4f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x02\x9a\x13\xe8\x16\x35\x08\x75\x02\x00\x00\x00\x00\x00\x00\x4a\x02\x5c\x02\x00\x00\x00\x00\x00\x00\x62\x02\x31\x02\x56\x02\xf3\x07\x00\x00\xee\x07\x00\x00\x00\x00\xab\x1d\x90\x1d\x00\x00\x00\x00\x75\x1d\x00\x00\x5a\x1d\x00\x00\x98\x06\x00\x00\x4e\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x01\xe9\x07\x00\x00\x7b\x16\x53\x16\x5b\x1f\x00\x00\xe7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x00\x00\x5b\x02\x00\x00\x00\x00\x00\x00\x00\x00\x69\x05\x9b\x00\x78\x00\x50\x00\x89\x16\x00\x00\x00\x00\xac\x03\x3f\x1d\xc7\x1f\x24\x1d\xe2\x1f\x08\x15\x84\x15\xfd\x1f\xf1\x0b\x6f\x0b\xf0\x0c\xbb\x0c\x40\x0c\x3a\x0b\x9b\x0c\x1a\x0b\xfc\x07\x26\x07\xc1\x0b\x2c\x0a\x9d\x09\x00\x00\x40\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x1d\xee\x1c\xdb\x01\xcd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x99\x07\x00\x00\x00\x00\x00\x00\xc6\x01\x61\x04\x00\x00\x73\x13\xda\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x06\x35\x02\x33\x02\xea\x01\x7e\x01\x18\x06\x25\x1f\x00\x00\x00\x00\xa6\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x03\x91\x20\x87\x04\xdd\x01\xce\x07\x00\x00\x00\x00\xa6\x15\x4c\x04\xb7\x01\x00\x00\x00\x00\xda\x13\x26\x03\x00\x00\x00\x00\x6c\x05\x30\x13\x00\x00\x00\x00\xa2\x07\x36\x02\xb6\x0b\x00\x00\x26\x04\xa0\x01\x00\x00\x00\x00\xa7\x01\x4e\x15\xc7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x02\xb0\x01\x00\x00\x00\x00\xeb\x03\x60\x01\x00\x00\xa9\x16\x00\x00\x00\x00\xc4\x1b\x6a\x07\x14\x01\x40\x20\x18\x14\x28\x20\x9f\x01\x18\x00\x2c\x14\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x84\x20\x47\x07\x77\x20\x68\x14\xaf\x14\x2a\x15\xc5\x03\x4d\x01\x00\x00\x00\x00\x73\x07\xd3\x01\xeb\x04\x27\x07\x00\x00\x20\x07\x00\x00\x15\x07\x00\x00\x00\x00\xbf\x03\x00\x00\x00\x00\xb9\x01\x00\x00\x00\x00\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x01\x00\x00\x00\x00\x00\x00\x00\x00\x44\x04\x15\x07\x00\x00\xd9\x06\x00\x00\xa9\x1b\x00\x00\x00\x00\x00\x00\x16\x02\xf7\x01\xa9\x14\x00\x00\x6f\x13\x0d\x0e\xf4\x01\x00\x00\x00\x00\x0a\x14\x00\x00\x96\x06\x00\x00\x00\x04\x00\x00\x3e\x13\x60\x17\x76\x06\x68\x06\x00\x00\x06\x13\x59\x17\x2b\x06\x00\x00\x10\x06\xe2\x05\x00\x00\xdb\x00\x62\x17\x00\x00\x00\x00\xdf\x05\x00\x00\x00\x00\x00\x00\xe0\x16\xd9\x05\x00\x00\x00\x00\xd2\x14\x64\x03\x42\x01\x00\x00\x00\x00\x00\x00\x31\x16\x5c\x01\x00\x00\x00\x00\xff\x05\x00\x00\xf9\x08\x60\x07\x00\x00\xf1\x05\xe4\x05\xe1\x05\x00\x00\x00\x00\x00\x00\x92\x0c\x18\x04\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x01\x00\x00\x00\x00\x00\x00\x5e\x01\x57\x01\xae\x05\x93\x05\x78\x05\x00\x00\x31\x1c\x16\x1c\xd3\x1c\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x01\x33\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x09\x43\x01\xc4\x07\x3e\x01\x00\x00\x36\x07\x00\x00\x40\x16\xd5\xff\xe1\x14\x00\x00\x00\x00\x00\x00\xc7\x02\x00\x00\x8a\x02\x00\x00\x00\x00\xf9\x00\x96\x14\x00\x00\x00\x00\x13\x1b\x0a\x1f\x00\x00\x91\x1f\x00\x00\xef\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x1b\x9d\x02\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x1e\xd3\x00\xf1\x1a\x00\x00\x00\x00\x7f\x00\x00\x00\xb4\x05\x00\x00\x00\x00\x00\x00\x00\x00\xce\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x01\x67\x01\x36\x01\x1d\x01\x17\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\xff\x0e\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x80\x00\x00\x00\x00\x00\x00\x00\x99\x05\x00\x00\x00\x00\x6b\x0e\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x09\x5c\x05\x00\x00\x31\x16\x6a\x20\x00\x00\x00\x00\x00\x00\x04\x04\xb9\x16\x00\x00\x00\x00\x22\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x04\xb0\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x1e\x00\x00\x00\x00\x00\x00\x1a\x17\xfa\x05\x64\x14\x00\x00\x00\x00\x80\x16\x9a\x06\xca\x04\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x02\xaa\x0d\x36\x0d\xfa\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x1e\xd9\xff\x00\x00\x50\x1b\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x91\x06\xbf\x03\x5a\x05\x00\x00\x00\x00\x00\x00\x83\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x68\x1e\x57\x04\x61\x04\x78\x04\x00\x00\x09\x04\x00\x00\x86\x03\x00\x00\x4d\x1e\x00\x00\x00\x00\x5a\x05\xab\x03\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x04\xfb\x1b\xe0\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\xb8\x1c\x44\x00\x00\x00\x00\x00\x00\x00\x2c\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x1b\x00\x00\x00\x00\x73\x1b\x00\x00\x00\x00\x32\x1e\x35\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x1c\xf5\xff\x00\x00\xf1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x1e\x00\x00\x5f\x03\x5b\x20\xd0\xff\x00\x00\xfc\x1d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x1d\x00\x00\x00\x00\x00\x00\xec\x01\xd0\xff\x00\x00\xd6\x04\x9e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\xa5\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\xff\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x1c\x67\x1c\x00\x00\x00\x00\x00\x00\x91\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xfa\xff\x3d\xfe\x00\x00\x00\x00\x00\x00\x3d\xfe\x9b\xfe\x8f\xfe\x7d\xfe\x00\x00\x7b\xfe\x77\xfe\x74\xfe\x71\xfe\x6c\xfe\x69\xfe\x67\xfe\x65\xfe\x63\xfe\x61\xfe\x5f\xfe\x5c\xfe\x4f\xfe\x00\x00\xa5\xfe\xa4\xfe\x3d\xfe\x7e\xfe\x7f\xfe\x00\x00\x00\x00\x81\xfe\x80\xfe\x82\xfe\x83\xfe\x00\x00\x00\x00\x00\x00\x45\xfe\x46\xfe\x44\xfe\x43\xfe\xa6\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\xff\xe3\xff\xe2\xff\xe1\xff\xe0\xff\xdf\xff\xde\xff\x00\x00\x00\x00\xc7\xff\xd7\xff\xb5\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\xfe\x00\x00\x00\x00\xa6\xfe\x3e\xfe\x00\x00\xf7\xff\x00\x00\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x98\xff\x00\x00\x77\xff\x9b\xff\x8a\xff\x9a\xff\x89\xff\x99\xff\x88\xff\x6c\xff\x52\xff\x3d\xfe\x51\xff\x00\x00\xe5\xff\x0a\xff\x08\xff\x09\xff\xa6\xff\xfb\xfe\xfa\xfe\x00\x00\x3c\xfe\x3b\xfe\x00\x00\x3d\xfe\x00\x00\x8d\xff\x7e\xff\x86\xff\x7d\xff\x81\xff\x3d\xfe\x8f\xff\x82\xff\x84\xff\x83\xff\x8c\xff\x85\xff\x80\xff\x8e\xff\x4d\xff\x90\xff\x00\x00\x8b\xff\x4c\xff\x7f\xff\x87\xff\xfe\xfe\x60\xff\x00\x00\x3d\xfe\x00\x00\xf5\xff\x00\x00\x3d\xfe\x00\x00\x3c\xfe\x00\x00\x00\x00\x07\xff\xf9\xfe\x3c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\xff\x76\xff\x6b\xff\x26\xff\xa6\xff\x3a\xfe\x00\x00\x5a\xff\x2b\xff\x2f\xff\x2c\xff\x2d\xff\x2e\xff\x3d\xfe\x03\xff\xd7\xfe\xd5\xfe\xf4\xfe\x49\xfe\x00\x00\x96\xff\x75\xff\x6a\xff\x2a\xff\x26\xff\xa6\xff\x00\x00\x00\x00\x5d\xff\x00\x00\x66\xff\x54\xff\x53\xff\x62\xff\x92\xff\x91\xff\x61\xff\x6f\xff\x68\xff\x67\xff\xa9\xff\x6e\xff\x6d\xff\xaa\xff\x7b\xff\x72\xff\x73\xff\x71\xff\x7a\xff\x79\xff\x78\xff\x00\x00\x26\xff\x27\xff\x23\xff\x20\xff\x1f\xff\x24\xff\x16\xff\x28\xff\xa6\xff\x00\x00\x3d\xfe\x22\xff\x00\x00\x94\xff\x7c\xff\x70\xff\x26\xff\xa6\xff\x93\xff\x00\x00\x65\xff\x00\x00\x26\xff\xa6\xff\x3d\xfe\xa8\xff\x3d\xfe\xa7\xff\xf3\xff\x00\x00\x00\x00\x4a\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x3f\xfe\x4b\xfe\x00\x00\x00\x00\xbc\xff\x7d\xfe\x47\xfe\x00\x00\xbb\xff\x00\x00\xb4\xff\xd5\xff\x3d\xfe\xc6\xff\x3d\xfe\x3d\xfe\x00\x00\x85\xfe\x3d\xfe\x86\xfe\x8c\xfe\x42\xfe\x41\xfe\x8a\xfe\x3d\xfe\x88\xfe\x3d\xfe\x84\xfe\x8d\xfe\x8e\xfe\x00\x00\xde\xfe\x8a\xff\x89\xff\x88\xff\x00\x00\x00\x00\x00\x00\x3c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\xfe\x00\x00\x5a\xfe\x56\xfe\x55\xfe\x59\xfe\x58\xfe\x57\xfe\x52\xfe\x51\xfe\x50\xfe\x54\xfe\x53\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x95\xfe\x94\xfe\xf8\xff\xf9\xff\x97\xfe\x96\xfe\x00\x00\x00\x00\x91\xfe\x99\xfe\x5b\xfe\x78\xfe\x79\xfe\x7a\xfe\x75\xfe\x76\xfe\x72\xfe\x73\xfe\x6d\xfe\x6f\xfe\x6e\xfe\x70\xfe\x6a\xfe\x6b\xfe\x68\xfe\x66\xfe\x64\xfe\x62\xfe\x00\x00\x00\x00\x60\xfe\x4d\xfe\x4e\xfe\xa3\xfe\x00\x00\xdb\xfe\xd8\xfe\xda\xfe\xd9\xfe\x00\x00\xdc\xfe\xf4\xfe\xc8\xfe\xdd\xfe\xa2\xfe\x00\x00\x00\x00\x40\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\xff\xd5\xff\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xff\x00\x00\x3d\xfe\x00\x00\x00\x00\xbe\xff\x00\x00\xba\xff\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\xb6\xfe\x3d\xfe\x00\x00\xf1\xff\x3d\xfe\x3d\xfe\xb6\xfe\xef\xff\x21\xff\xf4\xfe\x00\x00\x1e\xff\x12\xff\x3c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\xff\x3d\xfe\xb6\xfe\xf0\xff\x4e\xff\x4b\xff\x3d\xfe\x00\x00\x95\xff\x74\xff\x69\xff\x29\xff\x26\xff\xa6\xff\x00\x00\x57\xff\x3d\xfe\xb6\xfe\xee\xff\x49\xfe\x48\xfe\x00\x00\x49\xfe\x82\xfe\x3d\xfe\xef\xfe\xeb\xfe\xe8\xfe\x9a\xff\x89\xff\xe4\xfe\x00\x00\xf3\xfe\xf1\xfe\x00\x00\x3c\xfe\xe0\xfe\xd4\xfe\xec\xff\xa5\xff\x00\x00\x00\x00\x00\x00\x00\x00\x3c\xfe\x3d\xfe\x3d\xfe\xb6\xfe\xf2\xff\x00\x00\x00\x00\x00\x00\x3d\xfe\xf6\xfe\xfd\xfe\x02\xff\x06\xff\x09\xff\x05\xff\xf8\xfe\x00\x00\x00\x00\x34\xff\x00\x00\x00\x00\x00\x00\x36\xfe\x00\x00\x38\xfe\x34\xfe\x35\xfe\x5f\xff\x5e\xff\x00\x00\x33\xff\x31\xff\x00\x00\x00\x00\x04\xff\x01\xff\xf5\xfe\x00\x00\x00\x00\xfc\xfe\x00\xff\xa1\xff\x00\x00\xeb\xff\x00\x00\x00\x00\x26\xff\x26\xff\x00\x00\x28\xff\x00\x00\x3d\xfe\x26\xff\xf7\xfe\x00\x00\x3d\xfe\xd6\xfe\x3d\xfe\xe2\xfe\x00\x00\xe3\xfe\xf4\xfe\xc8\xfe\x3d\xfe\x3d\xfe\xe7\xfe\xf4\xfe\xc8\xfe\x3d\xfe\xea\xfe\x3d\xfe\x3d\xfe\xee\xfe\x3d\xfe\x00\x00\x00\x00\x00\x00\x82\xfe\xd3\xfe\x00\x00\x00\x00\x49\xfe\x82\xfe\xa3\xff\xe7\xff\x3d\xfe\x3d\xfe\xb6\xfe\xed\xff\x00\x00\x00\x00\x3d\xfe\x4b\xff\x9d\xff\xe9\xff\x00\x00\x00\x00\x00\x00\x3d\xfe\x00\x00\x0f\xff\x1a\xff\x00\x00\x1d\xff\x1c\xff\x11\xff\x00\x00\x00\x00\xa4\xff\xe8\xff\x00\x00\x00\x00\x00\x00\x9f\xff\x9e\xff\xea\xff\x26\xff\x26\xff\x00\x00\x00\x00\x00\x00\xbd\xff\x4b\xfe\x4b\xfe\x00\x00\x00\x00\xdc\xff\x00\x00\x00\x00\xd6\xff\x00\x00\xd3\xff\x00\x00\xd4\xff\xd2\xff\xd0\xff\xd1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x60\xff\x3d\xfe\xdd\xff\x3d\xfe\x00\x00\x3d\xfe\x00\x00\x89\xfe\x87\xfe\x3d\xfe\xc6\xfe\xc4\xfe\x00\x00\x00\x00\x00\x00\x3c\xfe\xba\xfe\x7c\xfe\xb4\xfe\x00\x00\x5d\xfe\x00\x00\x98\xfe\x00\x00\x9a\xfe\x90\xfe\x5e\xfe\x4c\xfe\xb3\xfe\x00\x00\x00\x00\x00\x00\xac\xfe\xad\xfe\xb9\xfe\x00\x00\x00\x00\x00\x00\xb4\xfe\x00\x00\x00\x00\x00\x00\xc1\xfe\xc2\xfe\xc0\xfe\xc3\xfe\xc5\xfe\xc7\xfe\x3c\xfe\x00\x00\x00\x00\x9e\xfe\x00\x00\xcf\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x00\x00\xc9\xff\x00\x00\xb3\xff\x00\x00\x00\x00\x00\x00\x00\x00\xc5\xff\xc3\xff\xc2\xff\xb6\xfe\xb6\xfe\x00\x00\x64\xff\x63\xff\x00\x00\x1b\xff\x10\xff\x00\x00\x15\xff\x19\xff\x0d\xff\x0e\xff\x00\x00\x18\xff\x0b\xff\x3d\xfe\x40\xff\x49\xff\x00\x00\x00\x00\x3d\xfe\x3c\xfe\x4a\xff\x4f\xff\x3d\xfe\x5c\xff\x5b\xff\xa2\xff\xe6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x82\xfe\x3d\xfe\xd1\xfe\x00\x00\xd2\xfe\xcc\xfe\x00\x00\x00\x00\xed\xfe\xec\xfe\xe9\xfe\x3d\xfe\xc4\xfe\x3c\xfe\xe6\xfe\xe5\xfe\x3d\xfe\xc4\xfe\x3c\xfe\xe1\xfe\xf0\xfe\xf2\xfe\xdf\xfe\x00\x00\x00\x00\x00\x00\x26\xff\x59\xff\x58\xff\xb5\xfe\xff\xfe\xf4\xff\x00\x00\x00\x00\x00\x00\x38\xff\x00\x00\x00\x00\x36\xfe\x37\xfe\x39\xfe\x31\xfe\x00\x00\x32\xfe\x32\xff\x37\xff\x30\xff\x00\x00\x36\xff\x00\x00\x3c\xfe\x3c\xfe\x00\x00\xcf\xfe\xcb\xfe\x00\x00\x00\x00\xd0\xfe\xca\xfe\x56\xff\x55\xff\x46\xff\x44\xff\x3c\xff\x00\x00\x00\x00\x3c\xfe\x3d\xfe\x48\xff\x3d\xfe\x47\xff\x3d\xfe\x3f\xff\x00\x00\x50\xff\x17\xff\x00\x00\x00\x00\x14\xff\x25\xff\x9c\xff\xa0\xff\x00\x00\x4b\xfe\x4b\xfe\x00\x00\xda\xff\x00\x00\xb2\xff\xb1\xff\x00\x00\x00\x00\xb9\xff\xd8\xff\xc8\xff\xce\xff\xcc\xff\xcd\xff\x00\x00\xcb\xff\x9f\xfe\xa0\xfe\x00\x00\x00\x00\xa1\xfe\xbf\xfe\xbd\xfe\xbe\xfe\xbc\xfe\x00\x00\xa9\xfe\x00\x00\xae\xfe\xab\xfe\xa8\xfe\xaf\xfe\xb2\xfe\x00\x00\x93\xfe\xb1\xfe\x00\x00\x92\xfe\xaa\xfe\x00\x00\x00\x00\xb8\xfe\xbb\xfe\x9d\xfe\x00\x00\xca\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\xff\xc1\xff\x00\x00\x00\x00\xc4\xff\x13\xff\x3e\xff\x00\x00\x42\xff\x00\x00\x00\x00\x45\xff\x3b\xff\x00\x00\x39\xff\xc9\xfe\x00\x00\xce\xfe\x35\xff\x33\xfe\x00\x00\x30\xfe\xcd\xfe\x3a\xff\x3d\xfe\x43\xff\x3d\xff\x00\x00\x00\x00\x00\x00\xb8\xff\xb0\xff\x00\x00\x00\x00\x00\x00\x9c\xfe\xb7\xfe\x00\x00\xb0\xfe\xa7\xfe\x00\x00\x00\x00\xaf\xff\x00\x00\x00\x00\xd6\xff\xc0\xff\x41\xff\xbf\xff\x00\x00\xac\xff\xb7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\xff\xb6\xff\xad\xff\xae\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x02\x00\x03\x00\x04\x00\x36\x00\x74\x00\x15\x00\x16\x00\x17\x00\x15\x00\x16\x00\x17\x00\x17\x00\x04\x00\x35\x00\x01\x00\x01\x00\x18\x00\x03\x00\x01\x00\x04\x00\x02\x00\x1c\x00\x02\x00\x19\x00\x74\x00\x1b\x00\x0d\x00\x1d\x00\x1e\x00\x1f\x00\x0d\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x01\x00\x03\x00\x14\x00\x02\x00\x5b\x00\x0d\x00\x33\x00\x39\x00\x20\x00\x21\x00\x37\x00\x23\x00\x0d\x00\x21\x00\x02\x00\x03\x00\x04\x00\x1e\x00\x2e\x00\x2a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x79\x00\x01\x00\x79\x00\x36\x00\x76\x00\x01\x00\x2e\x00\x36\x00\x76\x00\x36\x00\x19\x00\x09\x00\x1b\x00\x0d\x00\x1d\x00\x1e\x00\x1f\x00\x0d\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x74\x00\x01\x00\x5e\x00\x74\x00\x74\x00\x5c\x00\x33\x00\x5e\x00\x74\x00\x5c\x00\x37\x00\x5e\x00\x5e\x00\x0d\x00\x02\x00\x03\x00\x04\x00\x77\x00\x78\x00\x79\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x5c\x00\x5d\x00\x42\x00\x43\x00\x44\x00\x5b\x00\x36\x00\x5c\x00\x5d\x00\x5e\x00\x19\x00\x5e\x00\x1b\x00\x79\x00\x1d\x00\x1e\x00\x1f\x00\x79\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x04\x00\x01\x00\x01\x00\x79\x00\x03\x00\x5c\x00\x33\x00\x5e\x00\x74\x00\x5c\x00\x37\x00\x5e\x00\x02\x00\x0d\x00\x0d\x00\x36\x00\x36\x00\x77\x00\x78\x00\x79\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x79\x00\x76\x00\x21\x00\x1e\x00\x23\x00\x23\x00\x01\x00\x07\x00\x5c\x00\x5d\x00\x5e\x00\x2a\x00\x2b\x00\x2c\x00\x04\x00\x7b\x00\x79\x00\x01\x00\x0d\x00\x02\x00\x33\x00\x01\x00\x2c\x00\x36\x00\x36\x00\x2a\x00\x5c\x00\x54\x00\x36\x00\x0d\x00\x02\x00\x54\x00\x01\x00\x0d\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x43\x00\x20\x00\x21\x00\x0d\x00\x23\x00\x48\x00\x77\x00\x78\x00\x79\x00\x01\x00\x21\x00\x2a\x00\x2b\x00\x2c\x00\x04\x00\x79\x00\x01\x00\x1e\x00\x2a\x00\x56\x00\x33\x00\x0d\x00\x79\x00\x36\x00\x5c\x00\x5c\x00\x5d\x00\x5e\x00\x0d\x00\x5c\x00\x5d\x00\x36\x00\x01\x00\x36\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x2d\x00\x02\x00\x21\x00\x0d\x00\x23\x00\x43\x00\x36\x00\x78\x00\x79\x00\x79\x00\x48\x00\x2a\x00\x2b\x00\x2c\x00\x04\x00\x5c\x00\x5d\x00\x5e\x00\x02\x00\x07\x00\x33\x00\x01\x00\x2d\x00\x36\x00\x56\x00\x07\x00\x5c\x00\x5d\x00\x5e\x00\x1e\x00\x5c\x00\x5d\x00\x5e\x00\x0d\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x5c\x00\x5d\x00\x21\x00\x21\x00\x23\x00\x23\x00\x5c\x00\x5d\x00\x79\x00\x07\x00\x01\x00\x2a\x00\x2b\x00\x2c\x00\x04\x00\x07\x00\x79\x00\x2a\x00\x5c\x00\x04\x00\x33\x00\x76\x00\x0d\x00\x37\x00\x36\x00\x5c\x00\x5d\x00\x5e\x00\x5c\x00\x5d\x00\x77\x00\x78\x00\x79\x00\x36\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x5c\x00\x5d\x00\x21\x00\x01\x00\x23\x00\x43\x00\x20\x00\x21\x00\x79\x00\x23\x00\x48\x00\x2a\x00\x2b\x00\x2c\x00\x04\x00\x0d\x00\x2a\x00\x2b\x00\x2c\x00\x02\x00\x33\x00\x79\x00\x1c\x00\x36\x00\x56\x00\x33\x00\x7a\x00\x7b\x00\x36\x00\x1c\x00\x5c\x00\x5d\x00\x5e\x00\x4b\x00\x41\x00\x42\x00\x43\x00\x44\x00\x74\x00\x41\x00\x42\x00\x43\x00\x44\x00\x21\x00\x2d\x00\x23\x00\x77\x00\x78\x00\x79\x00\x79\x00\x79\x00\x39\x00\x2a\x00\x2b\x00\x2c\x00\x01\x00\x36\x00\x54\x00\x39\x00\x2a\x00\x5c\x00\x33\x00\x5e\x00\x03\x00\x36\x00\x21\x00\x06\x00\x0d\x00\x54\x00\x43\x00\x05\x00\x06\x00\x07\x00\x2c\x00\x48\x00\x41\x00\x42\x00\x43\x00\x44\x00\x02\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x01\x00\x36\x00\x54\x00\x56\x00\x78\x00\x79\x00\x1f\x00\x34\x00\x35\x00\x5c\x00\x79\x00\x5e\x00\x0d\x00\x20\x00\x21\x00\x2a\x00\x20\x00\x21\x00\x2d\x00\x05\x00\x06\x00\x07\x00\x1e\x00\x09\x00\x1a\x00\x0b\x00\x0c\x00\x0d\x00\x07\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x2d\x00\x36\x00\x5c\x00\x5d\x00\x36\x00\x19\x00\x01\x00\x1b\x00\x03\x00\x1d\x00\x1e\x00\x1f\x00\x79\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x34\x00\x35\x00\x5c\x00\x5d\x00\x5e\x00\x74\x00\x33\x00\x54\x00\x0a\x00\x79\x00\x37\x00\x5a\x00\x0e\x00\x5c\x00\x76\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x54\x00\x6e\x00\x5c\x00\x5d\x00\x5e\x00\x1c\x00\x73\x00\x74\x00\x1c\x00\x76\x00\x42\x00\x43\x00\x44\x00\x79\x00\x2c\x00\x5a\x00\x79\x00\x5c\x00\x30\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x39\x00\x6e\x00\x76\x00\x39\x00\x54\x00\x1c\x00\x73\x00\x74\x00\x4b\x00\x76\x00\x77\x00\x78\x00\x79\x00\x05\x00\x06\x00\x07\x00\x0a\x00\x09\x00\x79\x00\x0b\x00\x0c\x00\x0d\x00\x76\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x01\x00\x1c\x00\x78\x00\x79\x00\x1c\x00\x19\x00\x39\x00\x1b\x00\x76\x00\x1d\x00\x1e\x00\x1f\x00\x0d\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x07\x00\x77\x00\x78\x00\x79\x00\x1c\x00\x39\x00\x33\x00\x07\x00\x39\x00\x1c\x00\x37\x00\x1c\x00\x1c\x00\x01\x00\x1a\x00\x2a\x00\x3c\x00\x3d\x00\x2d\x00\x01\x00\x1a\x00\x03\x00\x42\x00\x43\x00\x44\x00\x0d\x00\x07\x00\x22\x00\x23\x00\x1a\x00\x25\x00\x0d\x00\x27\x00\x39\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x39\x00\x07\x00\x39\x00\x39\x00\x20\x00\x21\x00\x33\x00\x5a\x00\x76\x00\x5c\x00\x37\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x36\x00\x6e\x00\x5c\x00\x5d\x00\x5e\x00\x4c\x00\x73\x00\x74\x00\x1a\x00\x76\x00\x77\x00\x78\x00\x79\x00\x79\x00\x07\x00\x41\x00\x42\x00\x43\x00\x44\x00\x5a\x00\x50\x00\x5c\x00\x1a\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x07\x00\x6e\x00\x5c\x00\x5d\x00\x5e\x00\x07\x00\x73\x00\x74\x00\x5c\x00\x5d\x00\x77\x00\x78\x00\x79\x00\x01\x00\x79\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x2a\x00\x74\x00\x03\x00\x2d\x00\x0d\x00\x06\x00\x22\x00\x23\x00\x79\x00\x25\x00\x76\x00\x27\x00\x79\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x07\x00\x02\x00\x03\x00\x36\x00\x1e\x00\x06\x00\x33\x00\x58\x00\x59\x00\x2a\x00\x37\x00\x36\x00\x2d\x00\x1f\x00\x1a\x00\x36\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x79\x00\x41\x00\x42\x00\x43\x00\x44\x00\x07\x00\x22\x00\x23\x00\x76\x00\x25\x00\x4c\x00\x27\x00\x08\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x33\x00\x5a\x00\x75\x00\x5c\x00\x37\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x76\x00\x6e\x00\x5c\x00\x5d\x00\x6d\x00\x4c\x00\x73\x00\x74\x00\x00\x00\x01\x00\x77\x00\x78\x00\x79\x00\x78\x00\x79\x00\x01\x00\x77\x00\x78\x00\x79\x00\x5a\x00\x2b\x00\x5c\x00\x5b\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x07\x00\x6e\x00\x41\x00\x42\x00\x43\x00\x44\x00\x73\x00\x74\x00\x36\x00\x02\x00\x77\x00\x78\x00\x79\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x5b\x00\x41\x00\x42\x00\x43\x00\x44\x00\x07\x00\x46\x00\x47\x00\x02\x00\x22\x00\x23\x00\x2b\x00\x25\x00\x01\x00\x27\x00\x01\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x4e\x00\x4f\x00\x50\x00\x19\x00\x04\x00\x1b\x00\x33\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x32\x00\x13\x00\x14\x00\x15\x00\x16\x00\x5b\x00\x33\x00\x01\x00\x4c\x00\x03\x00\x37\x00\x5c\x00\x5d\x00\x78\x00\x79\x00\x41\x00\x42\x00\x43\x00\x44\x00\x0d\x00\x5c\x00\x5d\x00\x5a\x00\x5e\x00\x5c\x00\x02\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x5a\x00\x6e\x00\x5c\x00\x04\x00\x5e\x00\x5f\x00\x73\x00\x74\x00\x2a\x00\x2b\x00\x77\x00\x78\x00\x79\x00\x21\x00\x5e\x00\x23\x00\x2a\x00\x2b\x00\x07\x00\x2a\x00\x2b\x00\x23\x00\x2a\x00\x2b\x00\x2c\x00\x73\x00\x74\x00\x02\x00\x2a\x00\x2b\x00\x2c\x00\x33\x00\x02\x00\x77\x00\x78\x00\x79\x00\x19\x00\x33\x00\x1b\x00\x2b\x00\x1d\x00\x1e\x00\x1f\x00\x04\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x07\x00\x2a\x00\x2b\x00\x36\x00\x5c\x00\x5d\x00\x33\x00\x4e\x00\x4f\x00\x50\x00\x37\x00\x77\x00\x78\x00\x79\x00\x41\x00\x42\x00\x43\x00\x44\x00\x19\x00\x04\x00\x1b\x00\x04\x00\x1d\x00\x1e\x00\x1f\x00\x2c\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x5a\x00\x2a\x00\x5c\x00\x01\x00\x5e\x00\x5f\x00\x33\x00\x79\x00\x2b\x00\x21\x00\x37\x00\x23\x00\x1e\x00\x79\x00\x5e\x00\x23\x00\x5c\x00\x5d\x00\x2a\x00\x2b\x00\x2c\x00\x07\x00\x2a\x00\x2b\x00\x2c\x00\x73\x00\x74\x00\x33\x00\x17\x00\x18\x00\x36\x00\x33\x00\x79\x00\x1e\x00\x36\x00\x5e\x00\x77\x00\x78\x00\x79\x00\x19\x00\x04\x00\x1b\x00\x04\x00\x1d\x00\x1e\x00\x1f\x00\x30\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x07\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x33\x00\x42\x00\x43\x00\x44\x00\x37\x00\x46\x00\x47\x00\x11\x00\x12\x00\x77\x00\x78\x00\x79\x00\x19\x00\x02\x00\x1b\x00\x5e\x00\x1d\x00\x1e\x00\x1f\x00\x04\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x79\x00\x36\x00\x77\x00\x78\x00\x79\x00\x04\x00\x33\x00\x77\x00\x78\x00\x79\x00\x37\x00\x23\x00\x41\x00\x42\x00\x43\x00\x44\x00\x32\x00\x04\x00\x2a\x00\x2b\x00\x2c\x00\x07\x00\x04\x00\x78\x00\x79\x00\x5c\x00\x5d\x00\x33\x00\x0b\x00\x0c\x00\x36\x00\x41\x00\x42\x00\x43\x00\x44\x00\x02\x00\x77\x00\x78\x00\x79\x00\x19\x00\x02\x00\x1b\x00\x02\x00\x1d\x00\x1e\x00\x1f\x00\x1f\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x07\x00\x01\x00\x2d\x00\x03\x00\x2a\x00\x2b\x00\x33\x00\x3c\x00\x78\x00\x79\x00\x37\x00\x2a\x00\x2b\x00\x0d\x00\x2b\x00\x77\x00\x78\x00\x79\x00\x19\x00\x2b\x00\x1b\x00\x02\x00\x1d\x00\x1e\x00\x1f\x00\x2b\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x79\x00\x05\x00\x06\x00\x07\x00\x5c\x00\x5d\x00\x33\x00\x36\x00\x1c\x00\x1d\x00\x37\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x36\x00\x21\x00\x2c\x00\x23\x00\x43\x00\x77\x00\x78\x00\x79\x00\x1e\x00\x48\x00\x2a\x00\x2b\x00\x2c\x00\x43\x00\x05\x00\x06\x00\x07\x00\x02\x00\x48\x00\x33\x00\x77\x00\x78\x00\x79\x00\x56\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x17\x00\x18\x00\x5e\x00\x56\x00\x02\x00\x42\x00\x43\x00\x44\x00\x02\x00\x5c\x00\x5d\x00\x5e\x00\x05\x00\x06\x00\x07\x00\x11\x00\x12\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x37\x00\x02\x00\x77\x00\x78\x00\x79\x00\x77\x00\x78\x00\x79\x00\x0b\x00\x0c\x00\x41\x00\x42\x00\x43\x00\x44\x00\x5a\x00\x02\x00\x5c\x00\x02\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x79\x00\x6e\x00\x77\x00\x78\x00\x79\x00\x2c\x00\x73\x00\x74\x00\x1e\x00\x76\x00\x5a\x00\x5c\x00\x5c\x00\x2d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x1e\x00\x6e\x00\x77\x00\x78\x00\x79\x00\x30\x00\x73\x00\x74\x00\x5a\x00\x76\x00\x5c\x00\x5b\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x02\x00\x6e\x00\x05\x00\x06\x00\x07\x00\x36\x00\x73\x00\x74\x00\x02\x00\x76\x00\x02\x00\x02\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x1f\x00\x43\x00\x04\x00\x02\x00\x36\x00\x02\x00\x48\x00\x4d\x00\x04\x00\x3b\x00\x3c\x00\x3d\x00\x05\x00\x06\x00\x07\x00\x41\x00\x42\x00\x43\x00\x44\x00\x04\x00\x56\x00\x04\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x3b\x00\x3c\x00\x3d\x00\x4e\x00\x4f\x00\x50\x00\x41\x00\x42\x00\x43\x00\x44\x00\x5e\x00\x5c\x00\x05\x00\x06\x00\x07\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x30\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x38\x00\x02\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x02\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x5a\x00\x79\x00\x5c\x00\x2b\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x79\x00\x6e\x00\x4e\x00\x4f\x00\x50\x00\x1f\x00\x73\x00\x74\x00\x5a\x00\x76\x00\x5c\x00\x01\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x02\x00\x6e\x00\x4e\x00\x4f\x00\x50\x00\x02\x00\x73\x00\x74\x00\x5a\x00\x76\x00\x5c\x00\x02\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x02\x00\x6e\x00\x05\x00\x06\x00\x07\x00\x2c\x00\x73\x00\x74\x00\x1f\x00\x76\x00\x2a\x00\x02\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x5e\x00\x04\x00\x04\x00\x4e\x00\x4f\x00\x50\x00\x4e\x00\x4f\x00\x50\x00\x3b\x00\x3c\x00\x3d\x00\x05\x00\x06\x00\x07\x00\x41\x00\x42\x00\x43\x00\x44\x00\x4e\x00\x4f\x00\x50\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x4e\x00\x4f\x00\x50\x00\x77\x00\x78\x00\x79\x00\x05\x00\x06\x00\x07\x00\x77\x00\x78\x00\x79\x00\x77\x00\x78\x00\x79\x00\x1f\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x38\x00\x01\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x2c\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x5a\x00\x79\x00\x5c\x00\x2c\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x1f\x00\x6e\x00\x77\x00\x78\x00\x79\x00\x02\x00\x73\x00\x74\x00\x5a\x00\x76\x00\x5c\x00\x02\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x08\x00\x6e\x00\x77\x00\x78\x00\x79\x00\x1f\x00\x73\x00\x74\x00\x5a\x00\x76\x00\x5c\x00\x01\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x5e\x00\x6e\x00\x05\x00\x06\x00\x07\x00\x1f\x00\x73\x00\x74\x00\x02\x00\x76\x00\x02\x00\x02\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x01\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x2b\x00\x42\x00\x43\x00\x44\x00\x2b\x00\x5b\x00\x05\x00\x06\x00\x07\x00\x41\x00\x42\x00\x43\x00\x44\x00\x77\x00\x78\x00\x79\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x77\x00\x78\x00\x79\x00\x5c\x00\x2a\x00\x5a\x00\x46\x00\x5c\x00\x02\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x2a\x00\x6e\x00\x2a\x00\x70\x00\x78\x00\x79\x00\x73\x00\x74\x00\x77\x00\x78\x00\x79\x00\x02\x00\x02\x00\x5a\x00\x79\x00\x5c\x00\x5e\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x2a\x00\x6e\x00\x4e\x00\x4f\x00\x50\x00\x1e\x00\x73\x00\x74\x00\x5a\x00\x76\x00\x5c\x00\x1a\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x1b\x00\x6e\x00\x0c\x00\x0d\x00\x19\x00\x10\x00\x73\x00\x74\x00\x04\x00\x76\x00\x01\x00\x5b\x00\x03\x00\x02\x00\x02\x00\x19\x00\x02\x00\x1b\x00\x5e\x00\x1d\x00\x1e\x00\x1f\x00\x0d\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x4e\x00\x4f\x00\x50\x00\x01\x00\x20\x00\x21\x00\x33\x00\x23\x00\x57\x00\x2b\x00\x37\x00\x4e\x00\x4f\x00\x50\x00\x2a\x00\x2b\x00\x2c\x00\x46\x00\x4e\x00\x4f\x00\x50\x00\x2b\x00\x5e\x00\x33\x00\x2c\x00\x01\x00\x36\x00\x2c\x00\x36\x00\x5a\x00\x01\x00\x5c\x00\x30\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x41\x00\x42\x00\x43\x00\x44\x00\x43\x00\x0d\x00\x2c\x00\x30\x00\x5a\x00\x48\x00\x5c\x00\x2c\x00\x5e\x00\x5f\x00\x60\x00\x37\x00\x01\x00\x73\x00\x74\x00\x3b\x00\x3c\x00\x3d\x00\x2c\x00\x56\x00\x03\x00\x41\x00\x42\x00\x43\x00\x44\x00\x5c\x00\x5d\x00\x5e\x00\x01\x00\x73\x00\x74\x00\x2b\x00\x02\x00\x77\x00\x78\x00\x79\x00\x30\x00\x31\x00\x2c\x00\x33\x00\x02\x00\x35\x00\x5b\x00\x5e\x00\x38\x00\x01\x00\x65\x00\x3b\x00\x01\x00\x3d\x00\x3e\x00\x3f\x00\x79\x00\x4e\x00\x4f\x00\x50\x00\x44\x00\x45\x00\x01\x00\x47\x00\x04\x00\x5e\x00\x4a\x00\x4b\x00\x01\x00\x4d\x00\x4e\x00\x5e\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x77\x00\x78\x00\x79\x00\x2c\x00\x65\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x01\x00\x77\x00\x78\x00\x79\x00\x1e\x00\x65\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x01\x00\x01\x00\x10\x00\x4e\x00\x4f\x00\x50\x00\x5a\x00\x1e\x00\x5c\x00\x01\x00\x5e\x00\x5f\x00\x60\x00\x1b\x00\x2b\x00\x38\x00\x2b\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x1e\x00\x41\x00\x42\x00\x43\x00\x44\x00\x2b\x00\x2b\x00\x2c\x00\x73\x00\x74\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x65\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x01\x00\x47\x00\x48\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\x01\x00\x77\x00\x78\x00\x79\x00\x01\x00\x01\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x5b\x00\x31\x00\x10\x00\x65\x00\x2a\x00\x5a\x00\x36\x00\x5c\x00\x1b\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x1b\x00\x3e\x00\x77\x00\x78\x00\x79\x00\x1a\x00\x43\x00\x77\x00\x78\x00\x79\x00\x47\x00\x48\x00\x77\x00\x78\x00\x79\x00\x19\x00\x4d\x00\x73\x00\x74\x00\x50\x00\x2f\x00\x52\x00\x31\x00\x10\x00\x33\x00\x56\x00\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x5e\x00\x3d\x00\x3e\x00\x3f\x00\x4e\x00\x4f\x00\x50\x00\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\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\x01\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x36\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\x47\x00\x19\x00\xff\xff\x1b\x00\x1b\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x77\x00\x78\x00\x79\x00\x2f\x00\xff\xff\x31\x00\x33\x00\x33\x00\xff\xff\x35\x00\x37\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\x78\x00\x79\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\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\x01\x00\x77\x00\x78\x00\x79\x00\xff\xff\x37\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x77\x00\x78\x00\x79\x00\x01\x00\x02\x00\x03\x00\x01\x00\x02\x00\x03\x00\x1b\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x01\x00\x02\x00\x03\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x42\x00\x43\x00\x44\x00\x33\x00\x01\x00\x35\x00\x03\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x0d\x00\x01\x00\x02\x00\x03\x00\x44\x00\x45\x00\x77\x00\x78\x00\x79\x00\xff\xff\x4a\x00\x4b\x00\x4c\x00\x04\x00\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\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\x01\x00\x78\x00\x79\x00\xff\xff\x36\x00\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x01\x00\x43\x00\x03\x00\xff\xff\x05\x00\x06\x00\x48\x00\xff\xff\x09\x00\x0a\x00\x1b\x00\xff\xff\x38\x00\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x56\x00\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x33\x00\x01\x00\x35\x00\x03\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x0d\x00\x0d\x00\x0e\x00\x0f\x00\x44\x00\x45\x00\x01\x00\x02\x00\x03\x00\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\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\x01\x00\x0d\x00\x0e\x00\x0f\x00\x36\x00\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x43\x00\x36\x00\xff\xff\xff\xff\xff\xff\x48\x00\x3b\x00\x3c\x00\x3d\x00\x1b\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\x5a\x00\x56\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x2b\x00\x2c\x00\x5e\x00\xff\xff\x2f\x00\x30\x00\xff\xff\x32\x00\xff\xff\x34\x00\xff\xff\xff\xff\x37\x00\xff\xff\x39\x00\x3a\x00\x37\x00\xff\xff\x73\x00\x74\x00\xff\xff\x40\x00\x41\x00\x42\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x49\x00\x46\x00\x47\x00\x4c\x00\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x78\x00\x79\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x0d\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\x1b\x00\xff\xff\xff\xff\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\x36\x00\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x43\x00\x01\x00\xff\xff\x03\x00\xff\xff\x48\x00\x5c\x00\x5d\x00\x5e\x00\x4c\x00\x4d\x00\xff\xff\x5a\x00\x0d\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x56\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x1b\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\x2f\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x43\x00\x03\x00\xff\xff\x01\x00\xff\xff\x48\x00\x01\x00\xff\xff\xff\xff\x4c\x00\x4d\x00\x0d\x00\x42\x00\x43\x00\x44\x00\x0d\x00\x46\x00\x47\x00\x0d\x00\x56\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\x36\x00\x5a\x00\xff\xff\x5c\x00\x36\x00\x5e\x00\x5f\x00\x36\x00\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\x78\x00\x79\x00\xff\xff\x43\x00\x48\x00\xff\xff\x43\x00\xff\xff\x48\x00\xff\xff\xff\xff\x48\x00\x73\x00\x74\x00\x2f\x00\x5a\x00\xff\xff\x5c\x00\x56\x00\x5e\x00\x5f\x00\x36\x00\x56\x00\xff\xff\x5c\x00\x56\x00\x5e\x00\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5c\x00\x5d\x00\x5e\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x73\x00\x74\x00\xff\xff\x4c\x00\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x01\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\xff\xff\x03\x00\xff\xff\x0d\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x01\x00\x1b\x00\x03\x00\xff\xff\xff\xff\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x73\x00\x74\x00\x2c\x00\x2d\x00\x36\x00\x2f\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x1b\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x73\x00\x74\x00\x4c\x00\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x4c\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\x1b\x00\x46\x00\x47\x00\x5a\x00\x01\x00\x5c\x00\x03\x00\x5e\x00\x5f\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x73\x00\x74\x00\x1b\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\xff\xff\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\x2c\x00\xff\xff\x4c\x00\x2f\x00\x78\x00\x79\x00\xff\xff\x01\x00\xff\xff\x03\x00\x73\x00\x74\x00\x56\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x0d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\x73\x00\x74\x00\x36\x00\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x1b\x00\x5e\x00\x5f\x00\x60\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x5e\x00\xff\xff\x10\x00\x2f\x00\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x36\x00\xff\xff\x5a\x00\x1b\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\x2c\x00\xff\xff\x4c\x00\x2f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xff\xff\x36\x00\xff\xff\xff\xff\xff\xff\x4c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x01\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\x02\x00\xff\xff\xff\xff\x0d\x00\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x01\x00\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x79\x00\xff\xff\x10\x00\x73\x00\x74\x00\xff\xff\xff\xff\x36\x00\x2f\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x1b\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x73\x00\x74\x00\x4c\x00\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x4c\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x1b\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x2c\x00\xff\xff\x5a\x00\x2f\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\xff\xff\x1b\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x73\x00\x74\x00\xff\xff\x2f\x00\xff\xff\x4c\x00\x78\x00\x79\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x2f\x00\xff\xff\x4c\x00\xff\xff\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xff\xff\xff\xff\x4c\x00\x73\x00\x74\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x78\x00\x79\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x2f\x00\x37\x00\xff\xff\xff\xff\x4c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x1b\x00\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x4c\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\x01\x00\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\x2f\x00\xff\xff\xff\xff\xff\xff\x4c\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x4c\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\x0d\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x0d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x01\x00\xff\xff\xff\xff\xff\xff\x36\x00\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\x1b\x00\x30\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\x56\x00\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\x5e\x00\xff\xff\x2f\x00\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\xff\xff\x03\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x4c\x00\xff\xff\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\x01\x00\x31\x00\x03\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\x03\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\x03\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\x03\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\x03\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x01\x00\x31\x00\x03\x00\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\x31\x00\xff\xff\x33\x00\x0d\x00\x35\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x5d\x00\x5e\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x0d\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\xff\xff\x0d\x00\x38\x00\xff\xff\x01\x00\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x0d\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x1e\x00\x03\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\x36\x00\xff\xff\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x43\x00\x35\x00\xff\xff\xff\xff\x38\x00\x48\x00\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\x56\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x5c\x00\x4e\x00\x5e\x00\xff\xff\x51\x00\x36\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x43\x00\xff\xff\xff\xff\x1e\x00\x1f\x00\x48\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x5c\x00\xff\xff\x5e\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\x1e\x00\x1f\x00\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x33\x00\x42\x00\x43\x00\x44\x00\x37\x00\x46\x00\x47\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x1e\x00\x1f\x00\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\x78\x00\x79\x00\x37\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x1e\x00\x1f\x00\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x33\x00\x42\x00\x43\x00\x44\x00\x37\x00\x46\x00\x47\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x1f\x00\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\x1f\x00\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\x21\x00\x36\x00\x23\x00\xff\xff\x77\x00\x78\x00\x79\x00\x4a\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\x36\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\x21\x00\xff\xff\x23\x00\xff\xff\x21\x00\xff\xff\x23\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x79\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\x36\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\x78\x00\x79\x00\x42\x00\x43\x00\x44\x00\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x21\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x21\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x33\x00\x79\x00\xff\xff\x36\x00\x78\x00\x79\x00\x33\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x22\x00\x23\x00\xff\xff\x25\x00\xff\xff\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x33\x00\x25\x00\xff\xff\x27\x00\x37\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\x5a\x00\x4c\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x22\x00\x23\x00\xff\xff\x25\x00\xff\xff\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x22\x00\x23\x00\xff\xff\x25\x00\xff\xff\x27\x00\x4c\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\x5a\x00\x37\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\x4c\x00\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x22\x00\x23\x00\xff\xff\x25\x00\xff\xff\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\x22\x00\x23\x00\xff\xff\x25\x00\xff\xff\x27\x00\x4c\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\x5a\x00\x37\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\x4c\x00\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x22\x00\x23\x00\xff\xff\x25\x00\xff\xff\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x2e\x00\x2f\x00\x30\x00\x22\x00\x23\x00\x33\x00\x25\x00\xff\xff\x27\x00\x37\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x2e\x00\x2f\x00\x30\x00\x22\x00\x23\x00\x33\x00\x25\x00\xff\xff\x27\x00\x37\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\x22\x00\x23\x00\x37\x00\x25\x00\xff\xff\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\xff\xff\x4c\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\x77\x00\x78\x00\x79\x00\xff\xff\x22\x00\x23\x00\x4c\x00\x25\x00\xff\xff\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x77\x00\x78\x00\x79\x00\xff\xff\x23\x00\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2a\x00\x2b\x00\x2c\x00\x36\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\x36\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x23\x00\xff\xff\xff\xff\x36\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x36\x00\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\x73\x00\x74\x00\xff\xff\x37\x00\x77\x00\x78\x00\x79\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x37\x00\xff\xff\xff\xff\x36\x00\x71\x00\xff\xff\x73\x00\x74\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\x79\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x37\x00\x77\x00\x78\x00\x79\x00\x3b\x00\x3c\x00\x3d\x00\x37\x00\x36\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x73\x00\x74\x00\x77\x00\x78\x00\x79\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\x2b\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\xff\xff\x5d\x00\x5e\x00\x5f\x00\x2b\x00\xff\xff\xff\xff\x3e\x00\xff\xff\xff\xff\x31\x00\xff\xff\x43\x00\xff\xff\xff\xff\x36\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x3e\x00\xff\xff\x50\x00\xff\xff\x52\x00\x43\x00\xff\xff\xff\xff\x56\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x5e\x00\xff\xff\x50\x00\xff\xff\x52\x00\x2c\x00\xff\xff\xff\xff\x56\x00\xff\xff\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\xff\xff\x5e\x00\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x5d\x00\x5e\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x5d\x00\x5e\x00\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x5d\x00\x5e\x00\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x31\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\x54\x00\x55\x00\x56\x00\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\xff\xff\x5e\x00\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\x5d\x00\x5e\x00\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\x5d\x00\x5e\x00\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\x5d\x00\x5e\x00\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\x5d\x00\x5e\x00\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\xff\xff\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\x5d\x00\x5e\x00\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\xff\xff\x33\x00\xff\xff\x35\x00\xff\xff\xff\xff\x38\x00\x5d\x00\x5e\x00\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\xff\xff\x33\x00\xff\xff\x35\x00\x36\x00\xff\xff\x38\x00\x5d\x00\x5e\x00\x3b\x00\xff\xff\xff\xff\xff\xff\x3f\x00\xff\xff\xff\xff\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\x48\x00\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\x5e\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x53\x00\x76\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x53\x00\x76\x00\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\x76\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\x73\x00\x74\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x79\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x38\x00\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x31\x00\x41\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\x38\x00\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x38\x00\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x38\x00\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x38\x00\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\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\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\x88\x00\x4c\x00\x4d\x00\xa2\x01\x7b\x03\x5e\x03\x12\x03\x13\x03\x11\x03\x12\x03\x13\x03\x60\x03\x3d\xfe\xe6\x02\x25\x02\x8d\x01\x72\x03\xaa\x00\xcb\x01\x35\x03\x25\x03\x1a\x02\x7a\x03\x4e\x00\x69\x03\x4f\x00\x26\x02\x50\x00\x51\x00\x52\x00\xcc\x01\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xd4\x02\x16\x03\xf8\x00\x7b\x02\x82\x02\xef\x00\x5f\x00\x84\x01\xc7\x00\xb9\x00\x60\x00\xc8\x00\xf7\x01\xbc\x00\x3d\x01\x4c\x00\x4d\x00\x75\x01\x36\x03\x7b\x03\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x9c\x00\x25\x02\x4f\x03\xba\x00\x83\x02\xcb\x01\x76\x01\xbd\x00\xe2\x01\xf9\x00\x4e\x00\x71\x03\x4f\x00\x26\x02\x50\x00\x51\x00\x52\x00\xcc\x01\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x14\x03\x97\x01\x86\x00\x14\x03\x14\x03\x84\x00\x5f\x00\x86\x00\x73\x03\x84\x00\x60\x00\x86\x00\x86\x00\xd6\x00\x4b\x00\x4c\x00\x4d\x00\x68\x00\x69\x00\x6a\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\xf0\x00\x4b\x00\xc8\x01\x63\x00\xc9\x01\x2a\x00\xb6\x00\x84\x00\x98\x01\x86\x00\x4e\x00\x86\x00\x4f\x00\xc9\x00\x50\x00\x51\x00\x52\x00\xbe\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\xaa\x00\xcb\x01\x06\x02\x4f\x03\xaa\x00\x84\x00\x5f\x00\x86\x00\x6a\x03\x84\x00\x60\x00\x86\x00\x55\x03\xcc\x01\x07\x02\xdd\x01\xbd\x00\x68\x00\x69\x00\x6a\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x9c\x00\x39\x03\xab\x00\xfb\x02\xac\x00\xc4\x00\x25\x02\x3b\x03\x84\x00\x98\x01\x86\x00\xad\x00\x5d\x00\x5e\x00\xd7\x00\xe1\x02\xb7\x00\xd3\x02\x26\x02\xe0\x02\x5f\x00\x25\x02\x9d\x01\xae\x00\xc5\x00\x56\x03\xde\x01\x0a\x03\x3c\xfe\xf7\x01\x6d\x03\x0b\x03\xf6\x01\x26\x02\xaf\x00\x62\x00\x63\x00\x64\x00\xb0\x00\x66\x00\x67\x00\x3c\xfe\xd8\x00\xb9\x00\xf7\x01\xd9\x00\x3c\xfe\x68\x00\x69\x00\x6a\x00\xcb\x01\xb5\x00\xda\x00\x5d\x00\x5e\x00\x9e\x01\xbe\x00\xd4\x02\x6e\x03\xe1\x02\x3c\xfe\x5f\x00\xcc\x01\x60\x02\xba\x00\x84\x00\x84\x00\xd7\x00\x86\x00\xf7\x01\xf0\x00\x4b\x00\xb6\x00\xd5\x00\xa1\x00\xdb\x00\x62\x00\x63\x00\x64\x00\xdc\x00\x66\x00\x67\x00\x54\x03\x41\x03\x9f\x01\xd6\x00\xa0\x01\xa2\x00\xae\x00\xb1\x00\x6a\x00\xc6\x00\xa3\x00\xa1\x01\x5d\x00\x5e\x00\x96\x00\x84\x00\xd7\x00\x86\x00\xf9\x01\x19\x03\x5f\x00\xec\x02\xe8\x02\xa2\x01\xa4\x00\x1a\x03\x84\x00\xd7\x00\x86\x00\x42\x03\x84\x00\xd7\x00\x86\x00\xf7\x01\xa3\x01\x62\x00\x63\x00\x64\x00\xa4\x01\x66\x00\x67\x00\x84\x00\xd7\x00\x97\x00\xc3\x00\x98\x00\xc4\x00\xf0\x00\x4b\x00\xdd\x00\x1b\x03\x6c\x00\x99\x00\x5d\x00\x5e\x00\x86\x02\x1d\x03\xb7\x00\xfa\x01\x84\x00\x89\x02\x5f\x00\x28\x03\x6d\x00\x0c\x02\xc5\x00\x84\x00\x98\x01\x86\x00\xf0\x00\x4b\x00\xc1\x02\x80\x02\x6a\x00\xa1\x00\x9a\x00\x62\x00\x63\x00\x64\x00\x9b\x00\x66\x00\x67\x00\x84\x00\xd7\x00\xab\x00\xcb\x01\xac\x00\xa2\x00\xd8\x00\xb9\x00\x9c\x00\xd9\x00\xa3\x00\xad\x00\x5d\x00\x5e\x00\x1c\x03\xcc\x01\xda\x00\x5d\x00\x5e\x00\x67\x02\x5f\x00\x60\x02\x98\x02\xae\x00\xa4\x00\x5f\x00\xda\x01\xdb\x01\xba\x00\x99\x02\x84\x00\xd7\x00\x86\x00\x8c\x02\xaf\x00\x62\x00\x63\x00\xd0\x01\x9a\x02\xdb\x00\x62\x00\x63\x00\xd0\x01\x9f\x01\xa8\x02\xa0\x01\x0d\x02\x8c\x00\x6a\x00\x9c\x00\xc6\x00\x84\x01\xa1\x01\x5d\x00\x5e\x00\x97\x01\xa1\x00\xb4\x02\x84\x01\x68\x02\x84\x00\x5f\x00\x86\x00\xa8\xfe\xa2\x01\xbc\x00\xa8\xfe\xd6\x00\xec\x01\xa2\x00\x6e\x03\x32\x00\x33\x00\xd7\x01\xa3\x00\xa3\x01\x62\x00\x63\x00\xd0\x01\x90\x02\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x25\x02\xbd\x00\x16\x02\xa4\x00\x87\x02\x6a\x00\xa8\xfe\xda\x02\xe1\x01\x84\x00\xdd\x00\x86\x00\x26\x02\xc0\x00\xb9\x00\x37\x03\xb8\x00\xb9\x00\x38\x03\x46\x02\x32\x00\x33\x00\x91\x02\x8d\x02\x19\x02\x48\x02\x49\x02\x4a\x02\x1b\x02\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x1e\x02\xba\x00\xf0\x00\x4b\x00\xba\x00\x4b\x02\xa9\x00\x4f\x00\xaa\x00\x50\x00\x4c\x02\x4d\x02\x9c\x00\x53\x00\x4e\x02\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xe0\x01\xe1\x01\x84\x00\x98\x01\x86\x00\x42\x02\x5f\x00\x20\x02\x70\x01\xbe\x00\x4f\x02\x06\x00\x71\x01\x07\x00\xe2\x01\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x2f\x02\x39\x00\x84\x00\xd7\x00\x86\x00\x89\x01\x18\x00\x19\x00\xa8\x01\x3a\x00\x92\x00\x63\x00\xe9\x01\xc1\x00\xe5\xff\x06\x00\xbb\x00\x07\x00\x86\x01\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x84\x01\x39\x00\xe2\x01\x84\x01\x35\x02\xc6\x01\x18\x00\x19\x00\x43\x02\x3a\x00\x68\x00\xc3\x01\x6a\x00\x46\x02\x32\x00\x33\x00\x44\x02\x47\x02\x60\x02\x48\x02\x49\x02\x4a\x02\x3f\x01\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x92\x01\x1a\x02\x95\x00\x6a\x00\x83\x01\x4b\x02\x84\x01\x4f\x00\x40\x01\x50\x00\x4c\x02\x4d\x02\xd6\x00\x53\x00\x4e\x02\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x0d\x01\x70\x03\x8c\x00\x6a\x00\x89\x01\x84\x01\x5f\x00\x86\x01\x84\x01\x99\x01\x4f\x02\xa8\x01\xc6\x01\x97\x01\x82\x01\xea\x02\x23\x02\xcf\x00\xeb\x02\x06\x02\x88\x01\xaa\x00\xc8\x01\x63\x00\xc9\x01\xd6\x00\x8a\x01\x0e\x01\x55\x00\x98\x01\x0f\x01\x07\x02\x10\x01\x84\x01\x11\x01\x5c\x00\x5d\x00\x5e\x00\x84\x01\x9a\x01\x84\x01\x84\x01\xc0\x00\xb9\x00\x5f\x00\x06\x00\x9b\x01\x07\x00\x12\x01\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xba\x00\x39\x00\x84\x00\xd7\x00\x86\x00\x68\x01\x18\x00\x19\x00\xa7\x01\x3a\x00\x68\x00\xc3\x01\x6a\x00\x9c\x00\xa9\x01\xcf\x01\x62\x00\x63\x00\xd0\x01\x06\x00\xbc\x01\x07\x00\xc5\x01\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0d\x01\x14\x01\x84\x00\x98\x01\x86\x00\xc7\x01\x18\x00\x19\x00\x84\x00\xd7\x00\x68\x00\x15\x01\x6a\x00\xf6\x01\x9c\x00\x7d\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x30\x03\xd4\x01\x75\x02\x31\x03\xf7\x01\x76\x02\x0e\x01\x55\x00\xc1\x00\x0f\x01\xd5\x01\x10\x01\x9c\x00\x11\x01\x5c\x00\x5d\x00\x5e\x00\x0d\x01\x20\x03\x21\x03\x9f\x00\x04\x03\x22\x03\x5f\x00\x2b\x03\x2c\x03\xdd\x02\x12\x01\xae\x00\xde\x02\x2e\x03\xa4\x00\xae\x00\x2b\x02\xce\x00\xcf\x00\x2c\x02\xd1\x00\x9c\x00\xd1\x01\x62\x00\x63\x00\xd0\x01\xe7\x00\x0e\x01\x55\x00\xed\x00\x0f\x01\x69\x01\x10\x01\xfa\x00\x11\x01\x5c\x00\x5d\x00\x5e\x00\x7e\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x5f\x00\x06\x00\x04\x01\x07\x00\x12\x01\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0a\x01\x14\x01\x84\x00\xd7\x00\x2b\x01\x6b\x01\x18\x00\x19\x00\x87\x00\x05\x00\x68\x00\x15\x01\x6a\x00\x2d\x02\x6a\x00\x05\x00\x7f\x02\x80\x02\x6a\x00\x06\x00\x7d\x03\x07\x00\x2a\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0d\x01\x14\x01\x38\x02\x62\x00\x63\x00\xd0\x01\x18\x00\x19\x00\xae\x00\x7e\x03\x68\x00\x15\x01\x6a\x00\x2b\x02\xce\x00\xcf\x00\x2c\x02\xd1\x00\x2a\x00\xd1\x01\x62\x00\x63\x00\x64\x00\xb5\x02\xd2\x01\x67\x00\x7f\x03\x0e\x01\x55\x00\x75\x03\x0f\x01\x76\x03\x10\x01\x77\x03\x11\x01\x5c\x00\x5d\x00\x5e\x00\x38\x03\xa6\x00\xa7\x00\xbe\x01\x69\x03\x4f\x00\x5f\x00\x50\x00\xbf\x01\xc0\x01\x12\x01\x53\x00\xc1\x01\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5a\x03\x20\x01\x21\x01\x22\x01\x23\x01\x2a\x00\x5f\x00\x65\x01\x13\x01\xaa\x00\xc2\x01\xf0\x00\x4b\x00\x2d\x02\x6a\x00\xf9\x02\x62\x00\x63\x00\xd0\x01\x66\x01\x3d\x03\x3e\x03\x06\x00\x86\x00\x07\x00\x6c\x03\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x06\x00\x14\x01\x07\x00\x58\x03\x00\x01\x09\x00\x18\x00\x19\x00\xfe\x02\xff\x02\x68\x00\x15\x01\x6a\x00\x97\x00\x86\x00\x98\x00\x00\x03\x01\x03\xee\x01\xfa\x01\x19\x03\x98\x00\x99\x00\x5d\x00\x5e\x00\x18\x00\x19\x00\x5d\x03\x99\x00\x5d\x00\x5e\x00\x5f\x00\x5e\x03\x68\x00\xc3\x01\x6a\x00\xbe\x01\x5f\x00\x4f\x00\x60\x03\x50\x00\xbf\x01\xc0\x01\x63\x03\x53\x00\xc1\x01\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x17\x02\xfa\x01\x8f\x02\xa2\x01\xf0\x00\x4b\x00\x5f\x00\x26\x02\xa6\x00\xa7\x00\xc2\x01\x49\x03\x8c\x00\x6a\x00\xe5\x01\x62\x00\x63\x00\xd0\x01\xbe\x01\x64\x03\x4f\x00\x65\x03\x50\x00\xbf\x01\xc0\x01\x3d\x00\x53\x00\xc1\x01\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x06\x00\x40\x03\x07\x00\x3f\x03\x02\x01\x09\x00\x5f\x00\x9c\x00\x43\x03\x9f\x01\xc2\x01\xa0\x01\x49\x03\x9c\x00\x86\x00\xac\x00\xf0\x00\x4b\x00\xa1\x01\x5d\x00\x5e\x00\x21\x02\xad\x00\x5d\x00\x5e\x00\x18\x00\x19\x00\x5f\x00\x1e\x01\x1f\x01\xa2\x01\x5f\x00\x9c\x00\x4f\x03\xae\x00\x86\x00\x68\x00\xc3\x01\x6a\x00\xbe\x01\x51\x03\x4f\x00\x53\x03\x50\x00\xbf\x01\xc0\x01\x86\x01\x53\x00\xc1\x01\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x30\x02\x92\x01\xcf\x00\x93\x01\xd1\x00\x9d\x02\x5f\x00\x92\x00\x63\x00\x93\x00\xc2\x01\x94\x00\x67\x00\x24\x01\x25\x01\x68\x00\xc3\x01\x6a\x00\xbe\x01\xe3\x02\x4f\x00\x86\x00\x50\x00\xbf\x01\xc0\x01\xf0\x02\x53\x00\xc1\x01\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x9c\x00\xae\x00\xfb\x02\xfc\x02\x6a\x00\xf1\x02\x5f\x00\x4a\x03\x8c\x00\x6a\x00\xc2\x01\xa0\x01\xd1\x01\x62\x00\x63\x00\xd0\x01\x4c\x03\xf4\x02\xa1\x01\x5d\x00\x5e\x00\x36\x02\xf5\x02\x95\x01\x6a\x00\xf0\x00\x4b\x00\x5f\x00\x26\x01\x27\x01\xa2\x01\xf9\x02\x62\x00\x63\x00\xd0\x01\xf6\x02\x68\x00\xc3\x01\x6a\x00\xbe\x01\xf7\x02\x4f\x00\x0a\x03\x50\x00\xbf\x01\xc0\x01\xee\x01\x53\x00\xc1\x01\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xbd\x01\x06\x02\x18\x03\xaa\x00\xe4\x00\xe5\x00\x5f\x00\x0d\x03\xd3\x01\x6a\x00\xc2\x01\xe6\x00\xe7\x00\x07\x02\x0e\x03\x68\x00\xc3\x01\x6a\x00\xbe\x01\x0f\x03\x4f\x00\x10\x03\x50\x00\xbf\x01\xc0\x01\x17\x03\x53\x00\xc1\x01\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x9c\x00\x6f\x03\x32\x00\x33\x00\xf0\x00\x4b\x00\x5f\x00\xa1\x00\x18\x01\x19\x01\xc2\x01\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xa1\x00\x97\x00\x3d\x00\x98\x00\xa2\x00\x4b\x03\x8c\x00\x6a\x00\x2b\x03\xa3\x00\x99\x00\x5d\x00\x5e\x00\xa2\x00\x45\x03\x32\x00\x33\x00\x1f\x03\xa3\x00\x5f\x00\x68\x00\xc3\x01\x6a\x00\xa4\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x1e\x01\x1f\x01\x86\x00\xa4\x00\x23\x03\xc8\x01\x63\x00\xc9\x01\x26\x03\x84\x00\xd7\x00\x86\x00\x10\x03\x32\x00\x33\x00\x24\x01\x25\x01\x77\x02\xa6\x00\xa7\x00\x78\x02\x79\x02\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xe8\x01\x27\x03\x68\x00\xc3\x01\x6a\x00\xf1\x02\x8c\x00\x6a\x00\x26\x01\x27\x01\x8f\x00\x62\x00\x63\x00\xd0\x01\x06\x00\x7c\x02\x07\x00\x7d\x02\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x9c\x00\x39\x00\xf2\x02\x8c\x00\x6a\x00\x63\x02\x18\x00\x19\x00\x3e\xfe\x3a\x00\x06\x00\xbc\x01\x07\x00\x8c\x02\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x92\x02\x39\x00\x68\x00\x91\x00\x6a\x00\x86\x01\x18\x00\x19\x00\x06\x00\x3a\x00\x07\x00\x2a\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x9c\x02\x39\x00\x95\x02\x32\x00\x33\x00\xa1\x00\x18\x00\x19\x00\x9d\x02\x3a\x00\xa5\x02\xa7\x02\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xee\x01\xa2\x00\xca\x00\xb3\x02\xa2\x01\xb4\x02\xa3\x00\xbc\x02\xbd\x02\x9e\x02\xce\x00\xcf\x00\x96\x02\x32\x00\x33\x00\xe5\x01\x62\x00\x63\x00\xd0\x01\xbf\x02\xa4\x00\xc0\x02\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x2a\x02\xce\x00\xcf\x00\x05\x03\xa6\x00\xa7\x00\xcf\x01\x62\x00\x63\x00\xd0\x01\x86\x00\xd1\x02\x97\x02\x32\x00\x33\x00\x66\x01\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x86\x01\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xcb\x00\xd6\x02\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd7\x02\xd2\x00\x62\x00\x63\x00\x64\x00\xd3\x00\x66\x00\x67\x00\x06\x00\x9c\x00\x07\x00\xda\x02\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x9c\x00\x39\x00\x26\x02\xa6\x00\xa7\x00\xdc\x02\x18\x00\x19\x00\x06\x00\x3a\x00\x07\x00\xdf\x02\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xdf\x01\x39\x00\x23\x03\xa6\x00\xa7\x00\xe0\x01\x18\x00\x19\x00\x06\x00\x3a\x00\x07\x00\xe5\x01\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xec\x01\x39\x00\x41\x02\x32\x00\x33\x00\xe4\x01\x18\x00\x19\x00\xee\x01\x3a\x00\xfb\x01\xfc\x01\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x86\x00\x12\x02\xe0\x00\x26\x02\xa6\x00\xa7\x00\xa2\x02\xa6\x00\xa7\x00\x2a\x02\xce\x00\xcf\x00\x52\x02\x32\x00\x33\x00\xcf\x01\x62\x00\x63\x00\xd0\x01\xa3\x02\xa6\x00\xa7\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x7d\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x26\x02\xa6\x00\xa7\x00\xb8\x02\x8c\x00\x6a\x00\x76\x01\x32\x00\x33\x00\xbd\x02\x8c\x00\x6a\x00\xc2\x02\x8c\x00\x6a\x00\xee\x01\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xe1\x00\x19\x02\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\x3d\x00\xd2\x00\x62\x00\x63\x00\x64\x00\xe2\x00\x66\x00\x67\x00\x06\x00\x9c\x00\x07\x00\x20\x02\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xee\x01\x39\x00\xc3\x02\x8c\x00\x6a\x00\x28\x02\x18\x00\x19\x00\x06\x00\x3a\x00\x07\x00\x29\x02\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x78\x01\x39\x00\xc4\x02\x8c\x00\x6a\x00\xee\x01\x18\x00\x19\x00\x06\x00\x3a\x00\x07\x00\x34\x02\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x86\x00\x39\x00\xf1\x00\x32\x00\x33\x00\xee\x01\x18\x00\x19\x00\x3a\x02\x3a\x00\x3b\x02\x3c\x02\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x40\x02\x92\x01\xcf\x00\x93\x01\xd1\x00\x9d\x02\x3d\x02\x92\x00\x63\x00\xe9\x01\x3e\x02\x2a\x00\x31\x00\x32\x00\x33\x00\xcf\x01\x62\x00\x63\x00\xd0\x01\xc8\x02\x8c\x00\x6a\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x7d\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\xc9\x02\x8c\x00\x6a\x00\xbc\x01\x54\x02\x06\x00\x46\x02\x07\x00\x57\x02\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x55\x02\xea\x00\x56\x02\x79\x01\x95\x01\x6a\x00\x18\x00\x19\x00\xcd\x02\x8c\x00\x6a\x00\x58\x02\x59\x02\x06\x00\x9c\x00\x07\x00\x86\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x64\x02\x39\x00\xd8\x02\xa6\x00\xa7\x00\x66\x02\x18\x00\x19\x00\x06\x00\x3a\x00\x07\x00\x1b\x01\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x1a\x01\x39\x00\x85\x02\x4a\x02\x1c\x01\x1d\x01\x18\x00\x19\x00\x69\x02\x3a\x00\x06\x02\x6b\x01\xaa\x00\x5d\x01\x5e\x01\x4b\x02\x68\x01\x4f\x00\x86\x00\x50\x00\x4c\x02\x4d\x02\x07\x02\x53\x00\x4e\x02\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xa5\x00\xa6\x00\xa7\x00\x74\x01\xd8\x00\xb9\x00\x5f\x00\xd9\x00\x78\x01\x7c\x01\x4f\x02\xe6\x01\xa6\x00\xa7\x00\xda\x00\x5d\x00\x5e\x00\x73\x01\xe7\x01\xa6\x00\xa7\x00\x7e\x01\x86\x00\x5f\x00\x3d\x00\x88\x01\xba\x00\x3d\x00\x3d\xfe\x06\x00\x6c\x00\x07\x00\x86\x01\xf4\x00\x09\x00\x0a\x00\x49\x01\xf7\x01\x62\x00\x63\x00\xd0\x01\x3d\xfe\x6d\x00\xe5\xff\x86\x01\x06\x00\x3d\xfe\x07\x00\x3d\x00\xf4\x00\x09\x00\x03\x01\xa5\x02\x9e\x01\x18\x00\x19\x00\x8e\x01\xce\x00\xcf\x00\x3d\x00\x3d\xfe\xaa\x00\x8f\x00\x62\x00\x63\x00\xd0\x01\x84\x00\xd7\x00\x86\x00\xc5\x01\x18\x00\x19\x00\x3f\x01\xcd\x01\x68\x00\xc3\x01\x6a\x00\x6e\x00\x6f\x00\x3d\x00\x70\x00\xcf\x01\x71\x00\x2a\x00\x86\x00\x72\x00\xda\x01\xff\xff\x73\x00\x8a\x00\x74\x00\x75\x00\x76\x00\xdd\x00\xa5\x00\xa6\x00\xa7\x00\x77\x00\x78\x00\x8b\x00\x79\x00\x88\x02\x86\x00\x7a\x00\x7b\x00\x8e\x00\x7c\x00\x7d\x00\x86\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\xe9\x00\x68\x00\x90\x01\x6a\x00\x3d\x00\xff\xff\x84\x00\x85\x00\x86\x00\x87\x00\x1b\x00\x0e\x02\x8c\x00\x6a\x00\x3f\xfe\xfb\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\xea\x00\xed\x00\x23\x00\x26\x02\xa6\x00\xa7\x00\x06\x00\xf3\x00\x07\x00\xf1\x00\xf4\x00\x09\x00\x61\x02\x24\x00\xf4\x00\xcb\x00\xf8\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xfc\x00\xd2\x00\x62\x00\x63\x00\xd0\x01\xfd\x00\x3c\x00\x3d\x00\x18\x00\x19\x00\x25\x00\x3e\x00\x6f\x00\x3f\x00\x70\x00\x40\x00\x71\x00\x3d\xfe\x41\x00\x72\x00\x42\x00\x43\x00\x73\x00\xff\xff\x74\x00\x75\x00\x76\x00\x44\x00\x45\x00\x46\x00\x3d\xfe\x77\x00\x78\x00\xfe\x00\x79\x00\x3d\xfe\x47\x00\x7a\x00\x7b\x00\x26\x00\x7c\x00\x7d\x00\x48\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x3d\xfe\x49\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x4a\x00\x51\x02\x86\x00\x52\x02\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x34\x02\x8c\x00\x6a\x00\xff\x00\x00\x01\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x06\x01\x6f\x00\x23\x00\xff\xff\x17\x01\x06\x00\xa1\x00\x07\x00\x1a\x01\xf4\x00\x09\x00\x0a\x00\x4a\x01\x24\x00\x75\x00\x6f\x01\x8c\x00\x6a\x00\x1b\x01\xa2\x00\x80\x01\x8c\x00\x6a\x00\x79\x00\xa3\x00\x81\x01\x8c\x00\x6a\x00\x1c\x01\x7c\x00\x18\x00\x19\x00\x7e\x00\x25\x00\x80\x00\xd7\xff\x1d\x01\xd7\xff\xa4\x00\xd7\xff\xd7\xff\x00\x00\xd7\xff\x00\x00\x00\x00\xd7\xff\x86\x00\xd7\xff\xd7\xff\xd7\xff\x8b\x01\xa6\x00\xa7\x00\xd7\xff\xd7\xff\xd7\xff\x00\x00\xd7\xff\xd7\xff\x00\x00\xd7\xff\xd7\xff\x26\x00\xd7\xff\xd7\xff\x00\x00\xd7\xff\xd7\xff\xd7\xff\xd7\xff\xd7\xff\xd7\xff\xd7\xff\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xd7\xff\xd7\xff\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\xa5\x00\xa6\x00\xa7\x00\x00\x00\xae\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\xd1\x01\x62\x00\x63\x00\x64\x00\x00\x00\xd2\x01\x67\x00\x3e\x02\x00\x00\x4f\x00\x24\x00\x50\x00\xbf\x01\xc0\x01\x00\x00\x53\x00\xc1\x01\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x8b\x00\x8c\x00\x6a\x00\x25\x00\x00\x00\x6f\x00\x5f\x00\x70\x00\x00\x00\x71\x00\xc2\x01\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\xa5\x00\xa6\x00\xa7\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\xd3\x01\x6a\x00\x7a\x00\x7b\x00\x26\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x85\x00\x86\x00\x52\x02\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\xb4\x00\x8c\x00\x6a\x00\x00\x00\x59\x02\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x00\x00\x68\x00\xc3\x01\x6a\x00\x8d\x01\x47\x03\xaa\x00\x8d\x01\x09\x03\xaa\x00\x24\x00\x5a\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x8d\x01\xa2\x02\xaa\x00\x8d\x01\xa8\x02\xaa\x00\x00\x00\x00\x00\x92\x01\xcf\x00\x3d\x00\x00\x00\x00\x00\x25\x00\x92\x00\x63\x00\xe9\x01\x70\x00\x01\x02\x71\x00\xaa\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x02\x02\x8d\x01\xce\x01\xaa\x00\x77\x00\x78\x00\x68\x00\x5b\x02\x6a\x00\x00\x00\x7a\x00\x7b\x00\x26\x00\x8a\x02\x7d\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x85\x00\x86\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x95\x01\x6a\x00\x00\x00\x3c\xfe\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x38\x01\x3c\xfe\x39\x01\x00\x00\x3a\x01\x3b\x01\x3c\xfe\x00\x00\x3c\x01\x3d\x01\x24\x00\x00\x00\xe1\x00\x00\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\x3c\xfe\xd2\x00\x62\x00\x63\x00\xd0\x01\x00\x00\x84\x00\x00\x00\x86\x00\x00\x00\x25\x00\x8d\x01\xeb\x01\xaa\x00\x70\x00\x65\x01\x71\x00\xaa\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x66\x01\x28\x01\x29\x01\x2a\x01\x77\x00\x78\x00\xa9\x00\xce\x01\xaa\x00\x00\x00\x7a\x00\x7b\x00\x26\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x85\x00\x86\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x28\x01\x29\x01\x2a\x01\x3c\xfe\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x00\x00\x3c\xfe\xae\x00\x00\x00\x00\x00\x00\x00\x3c\xfe\x2b\x02\xce\x00\xcf\x00\x24\x00\x00\x00\x00\x00\xd1\x01\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x06\x00\x3c\xfe\x07\x00\x00\x00\xf4\x00\x09\x00\x46\x01\x3c\x00\x3d\x00\x86\x00\x00\x00\x25\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x00\x00\x42\x00\x43\x00\x8e\x00\x00\x00\x18\x00\x19\x00\x00\x00\x44\x00\x45\x00\x46\x00\x00\x00\x00\x00\x8f\x00\x62\x00\x63\x00\x64\x00\x47\x00\x90\x00\x67\x00\x26\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x01\x02\x00\x00\xaa\x00\x06\x03\x6a\x00\x49\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x4a\x00\x4b\x00\x02\x02\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xbb\x02\x00\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x91\x00\x6a\x00\x00\x00\x24\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x25\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\xa1\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x9e\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa2\x00\x65\x01\x00\x00\xaa\x00\x00\x00\xa3\x00\x84\x00\x9f\x00\x86\x00\x26\x00\x3c\xfe\x00\x00\x06\x00\x66\x01\x07\x00\x00\x00\xf4\x00\x09\x00\x47\x01\xa4\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x86\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x00\x00\x00\x00\x18\x00\x19\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x16\x02\x00\x00\x00\x00\x23\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x24\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x25\x00\xb3\x00\x00\x00\x81\x00\x82\x00\x83\x00\xa4\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\xa2\x00\xaa\x00\x00\x00\x25\x02\x00\x00\xa3\x00\xa1\x02\x00\x00\x00\x00\x26\x00\x3d\xfe\x02\x02\x92\x00\x63\x00\x93\x00\x26\x02\x94\x00\x67\x00\xf7\x01\xa4\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x86\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xaf\x01\x00\x00\x00\x00\x23\x00\x00\x00\x00\x00\xa1\x00\x06\x00\x00\x00\x07\x00\xa1\x00\x06\x01\x09\x00\xa1\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x95\x00\x6a\x00\x00\x00\xa2\x00\xa3\x00\x00\x00\xa2\x00\x00\x00\xa3\x00\x00\x00\x00\x00\xa3\x00\x18\x00\x19\x00\x25\x00\x06\x00\x00\x00\x07\x00\xa4\x00\x08\x01\x09\x00\x3d\xfe\xa4\x00\x00\x00\x84\x00\xa4\x00\x86\x00\x00\x00\x84\x00\xd7\x00\x86\x00\x84\x00\xd7\x00\x86\x00\x3d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x18\x00\x19\x00\x00\x00\x26\x00\xb0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2f\x02\x86\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x00\x00\x75\x02\x00\x00\xd6\x00\x76\x02\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x4b\x01\x1b\x00\x24\x00\x75\x02\x00\x00\x00\x00\x76\x02\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x18\x00\x19\x00\x77\x02\x66\x03\xa1\x00\x25\x00\x00\x00\x06\x00\x00\x00\x07\x00\x24\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x4d\x01\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x02\x34\x03\x00\x00\x25\x00\x00\x00\x18\x00\x19\x00\x26\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xd7\x00\x86\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x4a\x00\x4b\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x26\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x51\x01\x27\x00\x28\x00\x29\x00\x2a\x00\x4a\x00\x4b\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x11\x02\x00\x00\x00\x00\x23\x00\x00\x00\x92\x01\xcf\x00\x93\x01\xd1\x00\x22\x02\x00\x00\x92\x00\x63\x00\x93\x00\x24\x00\x94\x00\x67\x00\x06\x00\x1b\x00\x07\x00\x75\x02\x0b\x01\x09\x00\x76\x02\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\xfe\x18\x00\x19\x00\x24\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x48\x01\x00\x00\x3c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x3c\xfe\x00\x00\x77\x02\x00\x00\x26\x00\x25\x00\x95\x01\x6a\x00\x00\x00\x65\x01\x00\x00\xaa\x00\x18\x00\x19\x00\x3c\xfe\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x66\x01\x86\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x52\x01\x27\x00\x28\x00\x29\x00\x2a\x00\x4a\x00\x4b\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x18\x00\x19\x00\xa1\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x06\x00\x00\x00\x07\x00\x24\x00\xf4\x00\x09\x00\x03\x01\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x86\x00\x00\x00\x23\x00\x25\x00\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x06\x00\x24\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x4e\x01\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x77\x02\x00\x00\x26\x00\x25\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x00\x00\xa2\x01\x00\x00\x00\x00\x00\x00\x26\x00\x9e\x02\xce\x00\xcf\x00\x9f\x02\xd1\x00\x00\x00\xe5\x01\x62\x00\x63\x00\xd0\x01\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xcb\x01\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\xe6\x02\x00\x00\x00\x00\xcc\x01\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x4c\x01\x1b\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x9c\x00\x00\x00\x23\x00\x18\x00\x19\x00\x00\x00\x00\x00\xa1\x00\x25\x00\x00\x00\x06\x00\x00\x00\x07\x00\x24\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x4f\x01\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x02\x00\x00\x00\x00\x25\x00\x00\x00\x18\x00\x19\x00\x26\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x86\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x26\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x50\x01\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x92\x01\xcf\x00\x93\x01\xd1\x00\x22\x02\x00\x00\x92\x00\x63\x00\xe9\x01\x00\x00\x24\x00\x1b\x00\x45\x01\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x63\x02\x00\x00\x06\x00\x25\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x2a\x01\x00\x00\x24\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x18\x00\x19\x00\x00\x00\x25\x00\x00\x00\x26\x00\x95\x01\x6a\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x59\x01\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x25\x00\x00\x00\x26\x00\x00\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x0c\x01\x09\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x00\x00\x00\x00\x26\x00\x18\x00\x19\x00\x92\x01\xcf\x00\x93\x01\xd1\x00\x29\x02\x00\x00\x92\x00\x63\x00\xe9\x01\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x95\x01\x6a\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x25\x00\xd1\x02\x00\x00\x00\x00\x26\x00\x8e\x01\xce\x00\xcf\x00\x8f\x01\xd1\x00\x24\x00\x8f\x00\x62\x00\x63\x00\xd0\x01\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x26\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x90\x01\x6a\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x08\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x92\x01\xcf\x00\x93\x01\xd1\x00\x07\x03\x00\x00\x92\x00\x63\x00\xe9\x01\x0a\x01\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x25\x00\x00\x00\x00\x00\x00\x00\x26\x00\x95\x01\x6a\x00\x00\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x26\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x01\x00\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x66\x01\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x6d\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x00\x00\x00\x00\x23\x00\x00\x00\x3d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x00\x00\x00\x00\x00\x00\x24\x00\x6e\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x3d\xfe\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x86\x00\x00\x00\x25\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x06\x02\x00\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x26\x00\x00\x00\x07\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x2d\x01\x2e\x01\x2f\x01\x30\x01\x31\x01\x32\x01\x33\x01\x34\x01\x35\x01\x36\x01\x37\x01\x00\x00\x01\x02\x6f\x00\xaa\x00\x70\x00\x00\x00\x71\x00\x3d\xfe\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x02\x02\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x77\x00\x78\x00\x00\x00\x79\x00\x3d\xfe\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x3d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x01\x02\x6f\x00\xaa\x00\x70\x00\x00\x00\x71\x00\x3d\xfe\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x02\x02\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x77\x00\x78\x00\x00\x00\x79\x00\x3d\xfe\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x3d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x01\x02\x6f\x00\xaa\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x02\x02\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xb3\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xb4\x00\x86\x00\xcb\x01\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\xcc\x01\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xdf\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xe0\x00\x86\x00\xcb\x01\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\xcc\x01\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xa6\x01\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xa7\x01\x86\x00\xcb\x01\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\xcc\x01\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xb3\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xb4\x00\x86\x00\xcb\x01\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\xcc\x01\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xdf\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xe0\x00\x86\x00\xcb\x01\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\xcc\x01\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xa6\x01\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xa7\x01\x86\x00\xcb\x01\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\xcc\x01\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xb3\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xb4\x00\x86\x00\x65\x01\x6f\x00\xaa\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x66\x01\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xdf\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xe0\x00\x86\x00\x6c\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x3d\xfe\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x6d\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x77\x00\x78\x00\x00\x00\x79\x00\x3d\xfe\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x3d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x86\x00\x6c\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x6d\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xa6\x01\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xa7\x01\x86\x00\x6c\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x6d\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xb3\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xb4\x00\x86\x00\x06\x02\x6f\x00\xaa\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x07\x02\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xdf\x00\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\xe0\x00\x86\x00\x65\x01\x6f\x00\xaa\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x66\x01\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x9e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\xcb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x9f\x00\x86\x00\x00\x00\x6f\x00\x00\x00\x70\x00\xcc\x01\x71\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x9e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x6c\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x9f\x00\x86\x00\x72\x00\x00\x00\x00\x00\x73\x00\x6d\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x9e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x84\x00\x9f\x00\x86\x00\x00\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x6d\x00\x72\x00\x00\x00\xcb\x01\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\xcc\x01\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x9e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x01\x02\xfb\x02\xaa\x00\x00\x00\x00\x00\x00\x00\x84\x00\x9f\x00\x86\x00\x00\x00\xa1\x00\x00\x00\x02\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\xa2\x00\x71\x00\x00\x00\x00\x00\x72\x00\xa3\x00\x00\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x84\x00\x7d\x00\x86\x00\x00\x00\x9e\x00\x3d\xfe\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x9f\x00\x86\x00\x3d\xfe\x00\x00\x00\x00\xb0\x01\xb1\x01\x3d\xfe\x53\x00\xb2\x01\x55\x00\x56\x00\x57\x00\xb3\x01\xb4\x01\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x00\x00\x3d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x84\x00\x00\x00\x86\x00\xb5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x92\x01\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x00\x63\x00\xe9\x01\x00\x00\x00\x00\x00\x00\xb6\x01\xb7\x01\xb8\x01\x00\x00\x00\x00\x00\x00\x5c\x02\xa6\x00\xa7\x00\x5d\x02\x5e\x02\x00\x00\x00\x00\x00\x00\xb0\x01\xb1\x01\x00\x00\x53\x00\xb2\x01\x55\x00\x56\x00\x57\x00\xb3\x01\xb4\x01\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x00\x00\x92\x01\xcf\x00\x93\x01\xd1\x00\x29\x02\x5f\x00\x92\x00\x63\x00\x93\x00\xb5\x01\x94\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\xc7\x02\x6a\x00\x92\x00\x63\x00\xe9\x01\x00\x00\x00\x00\x00\x00\xb6\x01\xb7\x01\xb8\x01\x00\x00\x00\x00\x00\x00\x5c\x02\xa6\x00\xa7\x00\x5d\x02\x5e\x02\xb0\x01\xb1\x01\x00\x00\x53\x00\xb2\x01\x55\x00\x56\x00\x57\x00\xb3\x01\xb4\x01\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x95\x01\x6a\x00\xb5\x01\x92\x01\xcf\x00\x93\x01\xd1\x00\x94\x01\x00\x00\x92\x00\x63\x00\xe9\x01\x00\x00\x68\x00\xcc\x02\x6a\x00\x00\x00\x00\x00\x00\x00\xb6\x01\xb7\x01\xb8\x01\x00\x00\x00\x00\x00\x00\x5c\x02\xa6\x00\xa7\x00\x5d\x02\x5e\x02\xb0\x01\xb1\x01\x00\x00\x53\x00\xb2\x01\x55\x00\x56\x00\x57\x00\xb3\x01\xb4\x01\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x00\x00\x92\x01\xcf\x00\x93\x01\xd1\x00\x94\x01\x5f\x00\x92\x00\x63\x00\x93\x00\xb5\x01\x94\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x01\x6a\x00\x00\x00\x68\x00\x5f\x02\x6a\x00\x00\x00\x00\x00\x00\x00\xb6\x01\xb7\x01\xb8\x01\xb9\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x01\xb1\x01\x00\x00\x53\x00\xb2\x01\x55\x00\x56\x00\x57\x00\xb3\x01\xb4\x01\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\xb5\x01\x95\x01\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\xba\x01\x6a\x00\xb6\x01\xb7\x01\xb8\x01\x00\x00\x00\x00\x00\x00\xb0\x01\xb1\x01\x00\x00\x53\x00\xb2\x01\x55\x00\x56\x00\x57\x00\xb3\x01\xb4\x01\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x00\x00\xd8\x00\xb9\x00\x00\x00\xd9\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\xb5\x01\xda\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\xab\x00\xba\x00\xac\x00\x00\x00\x68\x00\xba\x01\x6a\x00\xce\x02\x00\x00\xad\x00\x5d\x00\x5e\x00\x07\x02\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x08\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x00\x00\x00\x00\xfc\x01\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\x01\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x00\x00\x00\x00\x68\x00\xba\x01\x6a\x00\x00\x00\x97\x00\x00\x00\x98\x00\x00\x00\xab\x00\x00\x00\xac\x00\x00\x00\x00\x00\x99\x00\x5d\x00\x5e\x00\xdd\x00\xad\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\xae\x00\x00\x00\x23\x02\xcf\x00\x00\x00\x00\x00\xfe\x01\xff\x01\xc8\x01\x63\x00\xc9\x01\xf2\x01\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x02\xa6\x00\xa7\x00\x78\x02\x79\x02\x97\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x9f\x01\x00\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x98\x00\xa1\x01\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x99\x00\x5d\x00\x5e\x00\x5f\x00\x9c\x00\x00\x00\xa2\x01\xf3\x01\x6a\x00\x5f\x00\x00\x00\x77\x02\xa6\x00\xa7\x00\x78\x02\x79\x02\x00\x00\xd4\x02\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\xf1\x01\x62\x00\x63\x00\xd0\x01\x0e\x01\x55\x00\x00\x00\x0f\x01\x00\x00\x10\x01\x00\x00\x11\x01\x5c\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x01\x55\x00\x5f\x00\x0f\x01\x00\x00\x10\x01\x12\x01\x11\x01\x5c\x00\x5d\x00\x5e\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x12\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x02\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x06\x00\x81\x02\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\xb7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x68\x00\x15\x01\x6a\x00\x0e\x01\x55\x00\x00\x00\x0f\x01\x00\x00\x10\x01\x00\x00\x11\x01\x5c\x00\x5d\x00\x5e\x00\x00\x00\x68\x00\x15\x01\x6a\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x12\x01\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x55\x01\x0e\x01\x55\x00\x00\x00\x0f\x01\x00\x00\x10\x01\xef\x01\x11\x01\x5c\x00\x5d\x00\x5e\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x06\x00\x12\x01\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\xf0\x01\x00\x00\x1c\x02\x00\x00\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x68\x00\x15\x01\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x1d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x68\x00\x15\x01\x6a\x00\x0e\x01\x55\x00\x00\x00\x0f\x01\x00\x00\x10\x01\x00\x00\x11\x01\x5c\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x12\x01\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x54\x01\x00\x00\x0e\x01\x55\x00\x00\x00\x0f\x01\x00\x00\x10\x01\x31\x02\x11\x01\x5c\x00\x5d\x00\x5e\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x06\x00\x12\x01\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x32\x02\x00\x00\xd7\x01\x00\x00\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x68\x00\x15\x01\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\xd8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x68\x00\x15\x01\x6a\x00\xa9\x02\x55\x00\x00\x00\x0f\x01\x00\x00\x10\x01\x00\x00\x11\x01\x5c\x00\x5d\x00\x5e\x00\x00\x00\xf7\x02\xab\x02\xac\x02\xa9\x02\x55\x00\x5f\x00\x0f\x01\x00\x00\x10\x01\xad\x02\x11\x01\x5c\x00\x5d\x00\x5e\x00\x00\x00\xaa\x02\xab\x02\xac\x02\x0e\x01\x55\x00\x5f\x00\x0f\x01\x00\x00\x10\x01\xad\x02\x11\x01\x5c\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x0e\x01\x55\x00\x12\x01\x0f\x01\x00\x00\x10\x01\x00\x00\x11\x01\x5c\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x12\x01\x00\x00\x84\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\xae\x02\x6a\x00\x00\x00\x0e\x01\x55\x00\x6d\x01\x0f\x01\x00\x00\x10\x01\x00\x00\x11\x01\x5c\x00\x5d\x00\x5e\x00\x68\x00\xae\x02\x6a\x00\x00\x00\xac\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x12\x01\xad\x00\x5d\x00\x5e\x00\xae\x00\x68\x00\x15\x01\x6a\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\xae\x00\x00\x00\xd1\x01\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x6e\x01\x00\x00\x00\x00\x68\x00\x15\x01\x6a\x00\x7e\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x00\x00\x00\x00\x00\x00\x5e\x01\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x98\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x99\x00\x5d\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x02\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x15\x01\x6a\x00\x00\x00\x00\x00\x7f\x02\xec\x02\x6a\x00\xf9\x02\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x62\x01\x63\x01\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\xab\x01\xa2\x01\x00\x00\x00\x00\x00\x00\x12\x02\x00\x00\x18\x00\x19\x00\x00\x00\x8d\x01\x13\x02\x14\x02\x6a\x00\x8e\x01\xce\x00\xcf\x00\x8f\x01\xd1\x00\x00\x00\x8f\x00\x62\x00\x63\x00\x64\x00\x00\x00\x90\x00\x67\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\xab\x01\xaa\x01\x00\x00\x00\x00\xae\x00\xb9\x02\x00\x00\x18\x00\x19\x00\x2b\x02\xce\x00\xcf\x00\x00\x00\x9c\x00\x00\x00\xd1\x01\x62\x00\x63\x00\xd0\x01\x68\x00\x90\x01\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\xab\x01\x00\x00\x00\x00\x00\x00\x00\x00\xac\x01\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x68\x00\xad\x01\x6a\x00\xc5\x02\x7f\x02\xed\x02\x6a\x00\x8e\x01\xce\x00\xcf\x00\xca\x02\x9f\x00\x00\x00\x8f\x00\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x8f\x00\x62\x00\x63\x00\xd0\x01\x00\x00\x5a\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x00\x00\x5a\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\xc0\x02\x00\x00\x68\x00\xc6\x02\x6a\x00\x00\x00\x00\x00\x18\x00\x19\x00\x68\x00\xcb\x02\x6a\x00\xb0\x02\x00\x00\x05\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\xb0\x02\x00\x00\xb1\x02\x00\x00\x00\x00\x85\x00\x86\x00\xb2\x02\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\xc0\x00\x7f\x00\x00\x00\x81\x00\x82\x00\x83\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x85\x00\x86\x00\xb2\x02\xc3\x00\x00\x00\x00\x00\x75\x00\x00\x00\x00\x00\x6f\x00\x00\x00\xa2\x00\x00\x00\x00\x00\xa1\x00\x79\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x00\x75\x00\x00\x00\x7e\x00\x00\x00\x80\x00\xa2\x00\x00\x00\x00\x00\xa4\x00\x79\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x00\x86\x00\x00\x00\x7e\x00\x00\x00\x80\x00\x3d\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x86\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x02\x85\x00\x86\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x86\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x3d\xfe\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x77\x00\x78\x00\x00\x00\x79\x00\x3d\xfe\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x3d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x01\x85\x00\x86\x00\x3b\xfe\x00\x00\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x00\x00\x3b\xfe\x00\x00\x00\x00\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x3b\xfe\x00\x00\x00\x00\x00\x00\x3b\xfe\x3b\xfe\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x3b\xfe\x3b\xfe\x3b\xfe\x3b\xfe\x3b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\xfe\x3b\xfe\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\xa6\x01\x80\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x01\x86\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x3d\xfe\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x3d\xfe\x77\x00\x78\x00\x00\x00\x79\x00\x3d\xfe\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x3d\xfe\x00\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x85\x00\x86\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x9e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\x9f\x00\x86\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x86\x00\x6f\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x75\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x79\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x80\x00\x00\x00\x82\x00\x83\x00\xa4\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x00\x00\x86\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x81\x00\x82\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x86\x00\xb2\x02\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x00\x00\x00\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\xa6\x01\x00\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\xa7\x01\x86\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x00\x00\x3b\xfe\xb4\x00\x86\x00\x3b\xfe\x00\x00\x3b\xfe\x00\x00\x3b\xfe\x00\x00\x00\x00\x00\x00\x3b\xfe\x3b\xfe\x3b\xfe\x00\x00\x00\x00\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x00\x00\x00\x00\x3b\xfe\x00\x00\x00\x00\x3b\xfe\x00\x00\x3b\xfe\x3b\xfe\x3b\xfe\x3b\xfe\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x3b\xfe\x3b\xfe\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\xa6\x01\x00\x00\x81\x00\x82\x00\x83\x00\xa4\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\xa7\x01\x86\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x81\x00\x82\x00\x83\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x85\x00\x86\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x81\x00\x82\x00\x83\x00\x00\x00\x70\x00\x00\x00\x71\x00\x00\x00\x00\x00\x72\x00\x9f\x00\x86\x00\x73\x00\x00\x00\x74\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x81\x00\x82\x00\x83\x00\x00\x00\x70\x00\x00\x00\x71\x00\xa1\x00\x00\x00\x72\x00\x85\x00\x86\x00\x73\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x77\x00\x78\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x7a\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x83\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x02\x86\x00\x27\x03\x6e\x02\x6f\x02\x70\x02\x71\x02\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x6c\x02\x73\x02\x6d\x02\x6e\x02\x6f\x02\x70\x02\x71\x02\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x31\x03\x73\x02\x00\x00\x32\x03\x6f\x02\x70\x02\x71\x02\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x73\x02\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x02\x18\x00\x19\x00\x00\x00\x67\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x02\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x72\x02\x00\x00\x2e\x03\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x72\x02\x00\x00\xd7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x72\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\xab\x01\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x18\x00\x19\x00\x00\x00\x06\x00\x00\x00\x07\x00\x9c\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\xea\x00\x00\x00\x43\x03\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\xea\x00\x00\x00\x44\x03\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\xea\x00\x00\x00\x93\x02\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\xea\x00\x00\x00\x94\x02\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\xea\x00\x00\x00\xeb\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x77\x03\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x78\x03\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x61\x03\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x3a\x03\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x92\x02\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x41\x01\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x42\x01\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x43\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x5a\x01\x00\x00\x00\x00\x5b\x01\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x7a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x7c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x7e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x7f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x03\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x03\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x03\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x03\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x03\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x03\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x51\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x02\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\xee\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x03\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x69\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x6b\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x02\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x45\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x6c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x64\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x59\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x56\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x06\x00\x00\x00\x07\x00\x00\x00\xf4\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x53\x01\x02\x02\xce\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x03\x02\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x04\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x09\x02\xce\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x0a\x02\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x03\x0b\x02\x5f\x01\xa6\x00\xa7\x00\x60\x01\x61\x01\x02\x03\x00\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\x01\x03\xf4\x01\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x02\x03\x00\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\x00\x00\xf4\x01\x62\x00\x63\x00\xd0\x01\xcb\x00\x00\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\x00\x00\xf4\x01\x62\x00\x63\x00\xd0\x01\xe1\x00\x00\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\x00\x00\xf4\x01\x62\x00\x63\x00\xd0\x01\x37\x02\x00\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\x00\x00\xf4\x01\x62\x00\x63\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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 (4, 463) [ + (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), + (119 , happyReduce_119), + (120 , happyReduce_120), + (121 , happyReduce_121), + (122 , happyReduce_122), + (123 , happyReduce_123), + (124 , happyReduce_124), + (125 , happyReduce_125), + (126 , happyReduce_126), + (127 , happyReduce_127), + (128 , happyReduce_128), + (129 , happyReduce_129), + (130 , happyReduce_130), + (131 , happyReduce_131), + (132 , happyReduce_132), + (133 , happyReduce_133), + (134 , happyReduce_134), + (135 , happyReduce_135), + (136 , happyReduce_136), + (137 , happyReduce_137), + (138 , happyReduce_138), + (139 , happyReduce_139), + (140 , happyReduce_140), + (141 , happyReduce_141), + (142 , happyReduce_142), + (143 , happyReduce_143), + (144 , happyReduce_144), + (145 , happyReduce_145), + (146 , happyReduce_146), + (147 , happyReduce_147), + (148 , happyReduce_148), + (149 , happyReduce_149), + (150 , happyReduce_150), + (151 , happyReduce_151), + (152 , happyReduce_152), + (153 , happyReduce_153), + (154 , happyReduce_154), + (155 , happyReduce_155), + (156 , happyReduce_156), + (157 , happyReduce_157), + (158 , happyReduce_158), + (159 , happyReduce_159), + (160 , happyReduce_160), + (161 , happyReduce_161), + (162 , happyReduce_162), + (163 , happyReduce_163), + (164 , happyReduce_164), + (165 , happyReduce_165), + (166 , happyReduce_166), + (167 , happyReduce_167), + (168 , happyReduce_168), + (169 , happyReduce_169), + (170 , happyReduce_170), + (171 , happyReduce_171), + (172 , happyReduce_172), + (173 , happyReduce_173), + (174 , happyReduce_174), + (175 , happyReduce_175), + (176 , happyReduce_176), + (177 , happyReduce_177), + (178 , happyReduce_178), + (179 , happyReduce_179), + (180 , happyReduce_180), + (181 , happyReduce_181), + (182 , happyReduce_182), + (183 , happyReduce_183), + (184 , happyReduce_184), + (185 , happyReduce_185), + (186 , happyReduce_186), + (187 , happyReduce_187), + (188 , happyReduce_188), + (189 , happyReduce_189), + (190 , happyReduce_190), + (191 , happyReduce_191), + (192 , happyReduce_192), + (193 , happyReduce_193), + (194 , happyReduce_194), + (195 , happyReduce_195), + (196 , happyReduce_196), + (197 , happyReduce_197), + (198 , happyReduce_198), + (199 , happyReduce_199), + (200 , happyReduce_200), + (201 , happyReduce_201), + (202 , happyReduce_202), + (203 , happyReduce_203), + (204 , happyReduce_204), + (205 , happyReduce_205), + (206 , happyReduce_206), + (207 , happyReduce_207), + (208 , happyReduce_208), + (209 , happyReduce_209), + (210 , happyReduce_210), + (211 , happyReduce_211), + (212 , happyReduce_212), + (213 , happyReduce_213), + (214 , happyReduce_214), + (215 , happyReduce_215), + (216 , happyReduce_216), + (217 , happyReduce_217), + (218 , happyReduce_218), + (219 , happyReduce_219), + (220 , happyReduce_220), + (221 , happyReduce_221), + (222 , happyReduce_222), + (223 , happyReduce_223), + (224 , happyReduce_224), + (225 , happyReduce_225), + (226 , happyReduce_226), + (227 , happyReduce_227), + (228 , happyReduce_228), + (229 , happyReduce_229), + (230 , happyReduce_230), + (231 , happyReduce_231), + (232 , happyReduce_232), + (233 , happyReduce_233), + (234 , happyReduce_234), + (235 , happyReduce_235), + (236 , happyReduce_236), + (237 , happyReduce_237), + (238 , happyReduce_238), + (239 , happyReduce_239), + (240 , happyReduce_240), + (241 , happyReduce_241), + (242 , happyReduce_242), + (243 , happyReduce_243), + (244 , happyReduce_244), + (245 , happyReduce_245), + (246 , happyReduce_246), + (247 , happyReduce_247), + (248 , happyReduce_248), + (249 , happyReduce_249), + (250 , happyReduce_250), + (251 , happyReduce_251), + (252 , happyReduce_252), + (253 , happyReduce_253), + (254 , happyReduce_254), + (255 , happyReduce_255), + (256 , happyReduce_256), + (257 , happyReduce_257), + (258 , happyReduce_258), + (259 , happyReduce_259), + (260 , happyReduce_260), + (261 , happyReduce_261), + (262 , happyReduce_262), + (263 , happyReduce_263), + (264 , happyReduce_264), + (265 , happyReduce_265), + (266 , happyReduce_266), + (267 , happyReduce_267), + (268 , happyReduce_268), + (269 , happyReduce_269), + (270 , happyReduce_270), + (271 , happyReduce_271), + (272 , happyReduce_272), + (273 , happyReduce_273), + (274 , happyReduce_274), + (275 , happyReduce_275), + (276 , happyReduce_276), + (277 , happyReduce_277), + (278 , happyReduce_278), + (279 , happyReduce_279), + (280 , happyReduce_280), + (281 , happyReduce_281), + (282 , happyReduce_282), + (283 , happyReduce_283), + (284 , happyReduce_284), + (285 , happyReduce_285), + (286 , happyReduce_286), + (287 , happyReduce_287), + (288 , happyReduce_288), + (289 , happyReduce_289), + (290 , happyReduce_290), + (291 , happyReduce_291), + (292 , happyReduce_292), + (293 , happyReduce_293), + (294 , happyReduce_294), + (295 , happyReduce_295), + (296 , happyReduce_296), + (297 , happyReduce_297), + (298 , happyReduce_298), + (299 , happyReduce_299), + (300 , happyReduce_300), + (301 , happyReduce_301), + (302 , happyReduce_302), + (303 , happyReduce_303), + (304 , happyReduce_304), + (305 , happyReduce_305), + (306 , happyReduce_306), + (307 , happyReduce_307), + (308 , happyReduce_308), + (309 , happyReduce_309), + (310 , happyReduce_310), + (311 , happyReduce_311), + (312 , happyReduce_312), + (313 , happyReduce_313), + (314 , happyReduce_314), + (315 , happyReduce_315), + (316 , happyReduce_316), + (317 , happyReduce_317), + (318 , happyReduce_318), + (319 , happyReduce_319), + (320 , happyReduce_320), + (321 , happyReduce_321), + (322 , happyReduce_322), + (323 , happyReduce_323), + (324 , happyReduce_324), + (325 , happyReduce_325), + (326 , happyReduce_326), + (327 , happyReduce_327), + (328 , happyReduce_328), + (329 , happyReduce_329), + (330 , happyReduce_330), + (331 , happyReduce_331), + (332 , happyReduce_332), + (333 , happyReduce_333), + (334 , happyReduce_334), + (335 , happyReduce_335), + (336 , happyReduce_336), + (337 , happyReduce_337), + (338 , happyReduce_338), + (339 , happyReduce_339), + (340 , happyReduce_340), + (341 , happyReduce_341), + (342 , happyReduce_342), + (343 , happyReduce_343), + (344 , happyReduce_344), + (345 , happyReduce_345), + (346 , happyReduce_346), + (347 , happyReduce_347), + (348 , happyReduce_348), + (349 , happyReduce_349), + (350 , happyReduce_350), + (351 , happyReduce_351), + (352 , happyReduce_352), + (353 , happyReduce_353), + (354 , happyReduce_354), + (355 , happyReduce_355), + (356 , happyReduce_356), + (357 , happyReduce_357), + (358 , happyReduce_358), + (359 , happyReduce_359), + (360 , happyReduce_360), + (361 , happyReduce_361), + (362 , happyReduce_362), + (363 , happyReduce_363), + (364 , happyReduce_364), + (365 , happyReduce_365), + (366 , happyReduce_366), + (367 , happyReduce_367), + (368 , happyReduce_368), + (369 , happyReduce_369), + (370 , happyReduce_370), + (371 , happyReduce_371), + (372 , happyReduce_372), + (373 , happyReduce_373), + (374 , happyReduce_374), + (375 , happyReduce_375), + (376 , happyReduce_376), + (377 , happyReduce_377), + (378 , happyReduce_378), + (379 , happyReduce_379), + (380 , happyReduce_380), + (381 , happyReduce_381), + (382 , happyReduce_382), + (383 , happyReduce_383), + (384 , happyReduce_384), + (385 , happyReduce_385), + (386 , happyReduce_386), + (387 , happyReduce_387), + (388 , happyReduce_388), + (389 , happyReduce_389), + (390 , happyReduce_390), + (391 , happyReduce_391), + (392 , happyReduce_392), + (393 , happyReduce_393), + (394 , happyReduce_394), + (395 , happyReduce_395), + (396 , happyReduce_396), + (397 , happyReduce_397), + (398 , happyReduce_398), + (399 , happyReduce_399), + (400 , happyReduce_400), + (401 , happyReduce_401), + (402 , happyReduce_402), + (403 , happyReduce_403), + (404 , happyReduce_404), + (405 , happyReduce_405), + (406 , happyReduce_406), + (407 , happyReduce_407), + (408 , happyReduce_408), + (409 , happyReduce_409), + (410 , happyReduce_410), + (411 , happyReduce_411), + (412 , happyReduce_412), + (413 , happyReduce_413), + (414 , happyReduce_414), + (415 , happyReduce_415), + (416 , happyReduce_416), + (417 , happyReduce_417), + (418 , happyReduce_418), + (419 , happyReduce_419), + (420 , happyReduce_420), + (421 , happyReduce_421), + (422 , happyReduce_422), + (423 , happyReduce_423), + (424 , happyReduce_424), + (425 , happyReduce_425), + (426 , happyReduce_426), + (427 , happyReduce_427), + (428 , happyReduce_428), + (429 , happyReduce_429), + (430 , happyReduce_430), + (431 , happyReduce_431), + (432 , happyReduce_432), + (433 , happyReduce_433), + (434 , happyReduce_434), + (435 , happyReduce_435), + (436 , happyReduce_436), + (437 , happyReduce_437), + (438 , happyReduce_438), + (439 , happyReduce_439), + (440 , happyReduce_440), + (441 , happyReduce_441), + (442 , happyReduce_442), + (443 , happyReduce_443), + (444 , happyReduce_444), + (445 , happyReduce_445), + (446 , happyReduce_446), + (447 , happyReduce_447), + (448 , happyReduce_448), + (449 , happyReduce_449), + (450 , happyReduce_450), + (451 , happyReduce_451), + (452 , happyReduce_452), + (453 , happyReduce_453), + (454 , happyReduce_454), + (455 , happyReduce_455), + (456 , happyReduce_456), + (457 , happyReduce_457), + (458 , happyReduce_458), + (459 , happyReduce_459), + (460 , happyReduce_460), + (461 , happyReduce_461), + (462 , happyReduce_462), + (463 , happyReduce_463) + ] + +happy_n_terms = 102 :: Int +happy_n_nonterms = 125 :: Int + +happyReduce_4 = happyMonadReduce 1# 0# happyReduction_4 +happyReduction_4 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut8 happy_x_1 of { happy_var_1 -> + ( let decls = reverse happy_var_1 in + case decls of + [] -> do{ n <- getNewName; p <- getCurrentPosition; return $ CTranslUnit decls (mkNodeInfo' p (p,0) n) } + (d:ds) -> withNodeInfo d $ CTranslUnit decls)} + ) (\r -> happyReturn (happyIn7 r)) + +happyReduce_5 = happySpecReduce_0 1# happyReduction_5 +happyReduction_5 = happyIn8 + (empty + ) + +happyReduce_6 = happySpecReduce_2 1# happyReduction_6 +happyReduction_6 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + happyIn8 + (happy_var_1 + )} + +happyReduce_7 = happySpecReduce_2 1# happyReduction_7 +happyReduction_7 happy_x_2 + happy_x_1 + = case happyOut8 happy_x_1 of { happy_var_1 -> + case happyOut9 happy_x_2 of { happy_var_2 -> + happyIn8 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_8 = happySpecReduce_1 2# happyReduction_8 +happyReduction_8 happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + happyIn9 + (CFDefExt happy_var_1 + )} + +happyReduce_9 = happySpecReduce_1 2# happyReduction_9 +happyReduction_9 happy_x_1 + = case happyOut32 happy_x_1 of { happy_var_1 -> + happyIn9 + (CDeclExt happy_var_1 + )} + +happyReduce_10 = happySpecReduce_2 2# happyReduction_10 +happyReduction_10 happy_x_2 + happy_x_1 + = case happyOut9 happy_x_2 of { happy_var_2 -> + happyIn9 + (happy_var_2 + )} + +happyReduce_11 = happyMonadReduce 5# 2# happyReduction_11 +happyReduction_11 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut123 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CAsmExt happy_var_3)}} + ) (\r -> happyReturn (happyIn9 r)) + +happyReduce_12 = happyMonadReduce 2# 3# happyReduction_12 +happyReduction_12 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut11 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef [] happy_var_1 [] happy_var_2))}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_13 = happyMonadReduce 3# 3# happyReduction_13 +happyReduction_13 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef (liftCAttrs happy_var_1) happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_14 = happyMonadReduce 3# 3# happyReduction_14 +happyReduction_14 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef happy_var_1 happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_15 = happyMonadReduce 3# 3# happyReduction_15 +happyReduction_15 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef happy_var_1 happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_16 = happyMonadReduce 3# 3# happyReduction_16 +happyReduction_16 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef (reverse happy_var_1) happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_17 = happyMonadReduce 3# 3# happyReduction_17 +happyReduction_17 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef (liftTypeQuals happy_var_1) happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_18 = happyMonadReduce 4# 3# happyReduction_18 +happyReduction_18 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef (liftTypeQuals happy_var_1 ++ liftCAttrs happy_var_2) happy_var_3 [] happy_var_4))}}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_19 = happyMonadReduce 3# 3# happyReduction_19 +happyReduction_19 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut76 happy_x_1 of { happy_var_1 -> + case happyOut33 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CFunDef [] happy_var_1 (reverse happy_var_2) happy_var_3)}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_20 = happyMonadReduce 4# 3# happyReduction_20 +happyReduction_20 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_2 of { happy_var_2 -> + case happyOut33 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_2 $ CFunDef (liftCAttrs happy_var_1) happy_var_2 (reverse happy_var_3) happy_var_4)}}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_21 = happyMonadReduce 4# 3# happyReduction_21 +happyReduction_21 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_2 of { happy_var_2 -> + case happyOut33 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CFunDef happy_var_1 happy_var_2 (reverse happy_var_3) happy_var_4)}}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_22 = happyMonadReduce 4# 3# happyReduction_22 +happyReduction_22 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_2 of { happy_var_2 -> + case happyOut33 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CFunDef happy_var_1 happy_var_2 (reverse happy_var_3) happy_var_4)}}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_23 = happyMonadReduce 4# 3# happyReduction_23 +happyReduction_23 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_2 of { happy_var_2 -> + case happyOut33 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CFunDef (reverse happy_var_1) happy_var_2 (reverse happy_var_3) happy_var_4)}}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_24 = happyMonadReduce 4# 3# happyReduction_24 +happyReduction_24 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_2 of { happy_var_2 -> + case happyOut33 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CFunDef (liftTypeQuals happy_var_1) happy_var_2 (reverse happy_var_3) happy_var_4)}}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_25 = happyMonadReduce 5# 3# happyReduction_25 +happyReduction_25 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut76 happy_x_3 of { happy_var_3 -> + case happyOut33 happy_x_4 of { happy_var_4 -> + case happyOut14 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CFunDef (liftTypeQuals happy_var_1 ++ liftCAttrs happy_var_2) happy_var_3 (reverse happy_var_4) happy_var_5)}}}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_26 = happyMonadReduce 1# 4# happyReduction_26 +happyReduction_26 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut72 happy_x_1 of { happy_var_1 -> + ( let declr = reverseDeclr happy_var_1 in + enterScope >> doFuncParamDeclIdent declr >> return declr)} + ) (\r -> happyReturn (happyIn11 r)) + +happyReduce_27 = happySpecReduce_1 5# happyReduction_27 +happyReduction_27 happy_x_1 + = case happyOut13 happy_x_1 of { happy_var_1 -> + happyIn12 + (happy_var_1 + )} + +happyReduce_28 = happySpecReduce_1 5# happyReduction_28 +happyReduction_28 happy_x_1 + = case happyOut14 happy_x_1 of { happy_var_1 -> + happyIn12 + (happy_var_1 + )} + +happyReduce_29 = happySpecReduce_1 5# happyReduction_29 +happyReduction_29 happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn12 + (happy_var_1 + )} + +happyReduce_30 = happySpecReduce_1 5# happyReduction_30 +happyReduction_30 happy_x_1 + = case happyOut23 happy_x_1 of { happy_var_1 -> + happyIn12 + (happy_var_1 + )} + +happyReduce_31 = happySpecReduce_1 5# happyReduction_31 +happyReduction_31 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn12 + (happy_var_1 + )} + +happyReduce_32 = happySpecReduce_1 5# happyReduction_32 +happyReduction_32 happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn12 + (happy_var_1 + )} + +happyReduce_33 = happyMonadReduce 1# 5# happyReduction_33 +happyReduction_33 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut26 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 (CAsm happy_var_1))} + ) (\r -> happyReturn (happyIn12 r)) + +happyReduce_34 = happyMonadReduce 4# 6# happyReduction_34 +happyReduction_34 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut125 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + case happyOut12 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CLabel happy_var_1 happy_var_4 happy_var_3)}}} + ) (\r -> happyReturn (happyIn13 r)) + +happyReduce_35 = happyMonadReduce 4# 6# happyReduction_35 +happyReduction_35 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut121 happy_x_2 of { happy_var_2 -> + case happyOut12 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CCase happy_var_2 happy_var_4)}}} + ) (\r -> happyReturn (happyIn13 r)) + +happyReduce_36 = happyMonadReduce 3# 6# happyReduction_36 +happyReduction_36 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut12 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CDefault happy_var_3)}} + ) (\r -> happyReturn (happyIn13 r)) + +happyReduce_37 = happyMonadReduce 6# 6# happyReduction_37 +happyReduction_37 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut121 happy_x_2 of { happy_var_2 -> + case happyOut121 happy_x_4 of { happy_var_4 -> + case happyOut12 happy_x_6 of { happy_var_6 -> + ( withNodeInfo happy_var_1 $ CCases happy_var_2 happy_var_4 happy_var_6)}}}} + ) (\r -> happyReturn (happyIn13 r)) + +happyReduce_38 = happyMonadReduce 5# 7# happyReduction_38 +happyReduction_38 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut17 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CCompound [] (reverse happy_var_3))}} + ) (\r -> happyReturn (happyIn14 r)) + +happyReduce_39 = happyMonadReduce 6# 7# happyReduction_39 +happyReduction_39 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + case happyOut17 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CCompound (reverse happy_var_3) (reverse happy_var_4))}}} + ) (\r -> happyReturn (happyIn14 r)) + +happyReduce_40 = happyMonadReduce 0# 8# happyReduction_40 +happyReduction_40 (happyRest) tk + = happyThen (( enterScope) + ) (\r -> happyReturn (happyIn15 r)) + +happyReduce_41 = happyMonadReduce 0# 9# happyReduction_41 +happyReduction_41 (happyRest) tk + = happyThen (( leaveScope) + ) (\r -> happyReturn (happyIn16 r)) + +happyReduce_42 = happySpecReduce_0 10# happyReduction_42 +happyReduction_42 = happyIn17 + (empty + ) + +happyReduce_43 = happySpecReduce_2 10# happyReduction_43 +happyReduction_43 happy_x_2 + happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_2 of { happy_var_2 -> + happyIn17 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_44 = happySpecReduce_1 11# happyReduction_44 +happyReduction_44 happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + happyIn18 + (CBlockStmt happy_var_1 + )} + +happyReduce_45 = happySpecReduce_1 11# happyReduction_45 +happyReduction_45 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn18 + (happy_var_1 + )} + +happyReduce_46 = happySpecReduce_1 12# happyReduction_46 +happyReduction_46 happy_x_1 + = case happyOut32 happy_x_1 of { happy_var_1 -> + happyIn19 + (CBlockDecl happy_var_1 + )} + +happyReduce_47 = happySpecReduce_1 12# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut20 happy_x_1 of { happy_var_1 -> + happyIn19 + (CNestedFunDef happy_var_1 + )} + +happyReduce_48 = happySpecReduce_2 12# happyReduction_48 +happyReduction_48 happy_x_2 + happy_x_1 + = case happyOut19 happy_x_2 of { happy_var_2 -> + happyIn19 + (happy_var_2 + )} + +happyReduce_49 = happyMonadReduce 3# 13# happyReduction_49 +happyReduction_49 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef happy_var_1 happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn20 r)) + +happyReduce_50 = happyMonadReduce 3# 13# happyReduction_50 +happyReduction_50 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef happy_var_1 happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn20 r)) + +happyReduce_51 = happyMonadReduce 3# 13# happyReduction_51 +happyReduction_51 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef (reverse happy_var_1) happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn20 r)) + +happyReduce_52 = happyMonadReduce 3# 13# happyReduction_52 +happyReduction_52 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut11 happy_x_2 of { happy_var_2 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef (liftTypeQuals happy_var_1) happy_var_2 [] happy_var_3))}}} + ) (\r -> happyReturn (happyIn20 r)) + +happyReduce_53 = happyMonadReduce 4# 13# happyReduction_53 +happyReduction_53 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut11 happy_x_3 of { happy_var_3 -> + case happyOut14 happy_x_4 of { happy_var_4 -> + ( leaveScope >> (withNodeInfo happy_var_1 $ CFunDef (liftTypeQuals happy_var_1 ++ liftCAttrs happy_var_2) happy_var_3 [] happy_var_4))}}}} + ) (\r -> happyReturn (happyIn20 r)) + +happyReduce_54 = happySpecReduce_3 14# happyReduction_54 +happyReduction_54 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut82 happy_x_2 of { happy_var_2 -> + happyIn21 + (happy_var_2 + )} + +happyReduce_55 = happyReduce 4# 14# happyReduction_55 +happyReduction_55 (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 happyOut82 happy_x_3 of { happy_var_3 -> + happyIn21 + (happy_var_1 `rappendr` happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_56 = happyMonadReduce 1# 15# happyReduction_56 +happyReduction_56 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CExpr Nothing)} + ) (\r -> happyReturn (happyIn22 r)) + +happyReduce_57 = happyMonadReduce 2# 15# happyReduction_57 +happyReduction_57 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut117 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CExpr (Just happy_var_1))} + ) (\r -> happyReturn (happyIn22 r)) + +happyReduce_58 = happyMonadReduce 5# 16# happyReduction_58 +happyReduction_58 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + case happyOut12 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CIf happy_var_3 happy_var_5 Nothing)}}} + ) (\r -> happyReturn (happyIn23 r)) + +happyReduce_59 = happyMonadReduce 7# 16# happyReduction_59 +happyReduction_59 (happy_x_7 `HappyStk` + happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + case happyOut12 happy_x_5 of { happy_var_5 -> + case happyOut12 happy_x_7 of { happy_var_7 -> + ( withNodeInfo happy_var_1 $ CIf happy_var_3 happy_var_5 (Just happy_var_7))}}}} + ) (\r -> happyReturn (happyIn23 r)) + +happyReduce_60 = happyMonadReduce 5# 16# 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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + case happyOut12 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CSwitch happy_var_3 happy_var_5)}}} + ) (\r -> happyReturn (happyIn23 r)) + +happyReduce_61 = happyMonadReduce 5# 17# 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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + case happyOut12 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CWhile happy_var_3 happy_var_5 False)}}} + ) (\r -> happyReturn (happyIn24 r)) + +happyReduce_62 = happyMonadReduce 7# 17# 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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut12 happy_x_2 of { happy_var_2 -> + case happyOut117 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CWhile happy_var_5 happy_var_2 True)}}} + ) (\r -> happyReturn (happyIn24 r)) + +happyReduce_63 = happyMonadReduce 9# 17# happyReduction_63 +happyReduction_63 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut119 happy_x_3 of { happy_var_3 -> + case happyOut119 happy_x_5 of { happy_var_5 -> + case happyOut119 happy_x_7 of { happy_var_7 -> + case happyOut12 happy_x_9 of { happy_var_9 -> + ( withNodeInfo happy_var_1 $ CFor (Left happy_var_3) happy_var_5 happy_var_7 happy_var_9)}}}}} + ) (\r -> happyReturn (happyIn24 r)) + +happyReduce_64 = happyMonadReduce 10# 17# happyReduction_64 +happyReduction_64 (happy_x_10 `HappyStk` + happy_x_9 `HappyStk` + happy_x_8 `HappyStk` + happy_x_7 `HappyStk` + happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut32 happy_x_4 of { happy_var_4 -> + case happyOut119 happy_x_5 of { happy_var_5 -> + case happyOut119 happy_x_7 of { happy_var_7 -> + case happyOut12 happy_x_9 of { happy_var_9 -> + ( withNodeInfo happy_var_1 $ CFor (Right happy_var_4) happy_var_5 happy_var_7 happy_var_9)}}}}} + ) (\r -> happyReturn (happyIn24 r)) + +happyReduce_65 = happyMonadReduce 3# 18# happyReduction_65 +happyReduction_65 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CGoto happy_var_2)}} + ) (\r -> happyReturn (happyIn25 r)) + +happyReduce_66 = happyMonadReduce 4# 18# happyReduction_66 +happyReduction_66 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CGotoPtr happy_var_3)}} + ) (\r -> happyReturn (happyIn25 r)) + +happyReduce_67 = happyMonadReduce 2# 18# happyReduction_67 +happyReduction_67 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CCont)} + ) (\r -> happyReturn (happyIn25 r)) + +happyReduce_68 = happyMonadReduce 2# 18# happyReduction_68 +happyReduction_68 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CBreak)} + ) (\r -> happyReturn (happyIn25 r)) + +happyReduce_69 = happyMonadReduce 3# 18# happyReduction_69 +happyReduction_69 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut119 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CReturn happy_var_2)}} + ) (\r -> happyReturn (happyIn25 r)) + +happyReduce_70 = happyMonadReduce 6# 19# happyReduction_70 +happyReduction_70 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + case happyOut123 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CAsmStmt happy_var_2 happy_var_4 [] [] [])}}} + ) (\r -> happyReturn (happyIn26 r)) + +happyReduce_71 = happyMonadReduce 8# 19# happyReduction_71 +happyReduction_71 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + case happyOut123 happy_x_4 of { happy_var_4 -> + case happyOut28 happy_x_6 of { happy_var_6 -> + ( withNodeInfo happy_var_1 $ CAsmStmt happy_var_2 happy_var_4 happy_var_6 [] [])}}}} + ) (\r -> happyReturn (happyIn26 r)) + +happyReduce_72 = happyMonadReduce 10# 19# happyReduction_72 +happyReduction_72 (happy_x_10 `HappyStk` + happy_x_9 `HappyStk` + happy_x_8 `HappyStk` + happy_x_7 `HappyStk` + happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + case happyOut123 happy_x_4 of { happy_var_4 -> + case happyOut28 happy_x_6 of { happy_var_6 -> + case happyOut28 happy_x_8 of { happy_var_8 -> + ( withNodeInfo happy_var_1 $ CAsmStmt happy_var_2 happy_var_4 happy_var_6 happy_var_8 [])}}}}} + ) (\r -> happyReturn (happyIn26 r)) + +happyReduce_73 = happyMonadReduce 12# 19# happyReduction_73 +happyReduction_73 (happy_x_12 `HappyStk` + happy_x_11 `HappyStk` + happy_x_10 `HappyStk` + happy_x_9 `HappyStk` + happy_x_8 `HappyStk` + happy_x_7 `HappyStk` + happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + case happyOut123 happy_x_4 of { happy_var_4 -> + case happyOut28 happy_x_6 of { happy_var_6 -> + case happyOut28 happy_x_8 of { happy_var_8 -> + case happyOut31 happy_x_10 of { happy_var_10 -> + ( withNodeInfo happy_var_1 $ CAsmStmt happy_var_2 happy_var_4 happy_var_6 happy_var_8 (reverse happy_var_10))}}}}}} + ) (\r -> happyReturn (happyIn26 r)) + +happyReduce_74 = happySpecReduce_0 20# happyReduction_74 +happyReduction_74 = happyIn27 + (Nothing + ) + +happyReduce_75 = happySpecReduce_1 20# happyReduction_75 +happyReduction_75 happy_x_1 + = case happyOut61 happy_x_1 of { happy_var_1 -> + happyIn27 + (Just happy_var_1 + )} + +happyReduce_76 = happySpecReduce_0 21# happyReduction_76 +happyReduction_76 = happyIn28 + ([] + ) + +happyReduce_77 = happySpecReduce_1 21# happyReduction_77 +happyReduction_77 happy_x_1 + = case happyOut29 happy_x_1 of { happy_var_1 -> + happyIn28 + (reverse happy_var_1 + )} + +happyReduce_78 = happySpecReduce_1 22# happyReduction_78 +happyReduction_78 happy_x_1 + = case happyOut30 happy_x_1 of { happy_var_1 -> + happyIn29 + (singleton happy_var_1 + )} + +happyReduce_79 = happySpecReduce_3 22# happyReduction_79 +happyReduction_79 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut29 happy_x_1 of { happy_var_1 -> + case happyOut30 happy_x_3 of { happy_var_3 -> + happyIn29 + (happy_var_1 `snoc` happy_var_3 + )}} + +happyReduce_80 = happyMonadReduce 4# 23# happyReduction_80 +happyReduction_80 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut123 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CAsmOperand Nothing happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn30 r)) + +happyReduce_81 = happyMonadReduce 7# 23# happyReduction_81 +happyReduction_81 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (CTokIdent _ happy_var_2) -> + case happyOut123 happy_x_4 of { happy_var_4 -> + case happyOut117 happy_x_6 of { happy_var_6 -> + ( withNodeInfo happy_var_1 $ CAsmOperand (Just happy_var_2) happy_var_4 happy_var_6)}}}} + ) (\r -> happyReturn (happyIn30 r)) + +happyReduce_82 = happyMonadReduce 7# 23# happyReduction_82 +happyReduction_82 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (CTokTyIdent _ happy_var_2) -> + case happyOut123 happy_x_4 of { happy_var_4 -> + case happyOut117 happy_x_6 of { happy_var_6 -> + ( withNodeInfo happy_var_1 $ CAsmOperand (Just happy_var_2) happy_var_4 happy_var_6)}}}} + ) (\r -> happyReturn (happyIn30 r)) + +happyReduce_83 = happySpecReduce_1 24# happyReduction_83 +happyReduction_83 happy_x_1 + = case happyOut123 happy_x_1 of { happy_var_1 -> + happyIn31 + (singleton happy_var_1 + )} + +happyReduce_84 = happySpecReduce_3 24# happyReduction_84 +happyReduction_84 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut31 happy_x_1 of { happy_var_1 -> + case happyOut123 happy_x_3 of { happy_var_3 -> + happyIn31 + (happy_var_1 `snoc` happy_var_3 + )}} + +happyReduce_85 = happyMonadReduce 2# 25# happyReduction_85 +happyReduction_85 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut45 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDecl (reverse happy_var_1) [])} + ) (\r -> happyReturn (happyIn32 r)) + +happyReduce_86 = happyMonadReduce 2# 25# happyReduction_86 +happyReduction_86 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut46 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDecl (reverse happy_var_1) [])} + ) (\r -> happyReturn (happyIn32 r)) + +happyReduce_87 = happyMonadReduce 2# 25# happyReduction_87 +happyReduction_87 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut36 happy_x_1 of { happy_var_1 -> + ( case happy_var_1 of CDecl declspecs dies at -> withLength at (CDecl declspecs (List.reverse dies)))} + ) (\r -> happyReturn (happyIn32 r)) + +happyReduce_88 = happyMonadReduce 2# 25# happyReduction_88 +happyReduction_88 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut34 happy_x_1 of { happy_var_1 -> + ( case happy_var_1 of CDecl declspecs dies at -> withLength at (CDecl declspecs (List.reverse dies)))} + ) (\r -> happyReturn (happyIn32 r)) + +happyReduce_89 = happySpecReduce_0 26# happyReduction_89 +happyReduction_89 = happyIn33 + (empty + ) + +happyReduce_90 = happySpecReduce_2 26# happyReduction_90 +happyReduction_90 happy_x_2 + happy_x_1 + = case happyOut33 happy_x_1 of { happy_var_1 -> + case happyOut32 happy_x_2 of { happy_var_2 -> + happyIn33 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_91 = happyMonadReduce 4# 27# happyReduction_91 +happyReduction_91 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + case happyOut91 happy_x_4 of { happy_var_4 -> + ( let declspecs = reverse happy_var_1 in + do{ declr <- withAsmNameAttrs happy_var_3 happy_var_2 + ; doDeclIdent declspecs declr + ; withNodeInfo happy_var_1 $ + CDecl declspecs [(Just (reverseDeclr declr), happy_var_4, Nothing)] })}}}} + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_92 = happyMonadReduce 4# 27# happyReduction_92 +happyReduction_92 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + case happyOut91 happy_x_4 of { happy_var_4 -> + ( let declspecs = liftTypeQuals happy_var_1 in + do{ declr <- withAsmNameAttrs happy_var_3 happy_var_2 + ; doDeclIdent declspecs declr + ; withNodeInfo happy_var_1 $ CDecl declspecs [(Just (reverseDeclr declr), happy_var_4, Nothing)] })}}}} + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_93 = happyMonadReduce 5# 27# happyReduction_93 +happyReduction_93 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut72 happy_x_3 of { happy_var_3 -> + case happyOut35 happy_x_4 of { happy_var_4 -> + case happyOut91 happy_x_5 of { happy_var_5 -> + ( let declspecs = liftTypeQuals happy_var_1 in + do{ declr <- withAsmNameAttrs happy_var_4 happy_var_3 + ; doDeclIdent declspecs declr + ; withNodeInfo happy_var_1 $ CDecl (declspecs ++ liftCAttrs happy_var_2) [(Just (reverseDeclr declr), happy_var_5, Nothing)] })}}}}} + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_94 = happyMonadReduce 4# 27# happyReduction_94 +happyReduction_94 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + case happyOut91 happy_x_4 of { happy_var_4 -> + ( let declspecs = liftCAttrs happy_var_1 in + do{ declr <- withAsmNameAttrs happy_var_3 happy_var_2 + ; doDeclIdent declspecs declr + ; withNodeInfo happy_var_1 $ CDecl declspecs [(Just (reverseDeclr declr), happy_var_4, Nothing)] })}}}} + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_95 = happyMonadReduce 6# 27# happyReduction_95 +happyReduction_95 (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) tk + = happyThen (case happyOut34 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + case happyOut72 happy_x_4 of { happy_var_4 -> + case happyOut35 happy_x_5 of { happy_var_5 -> + case happyOut91 happy_x_6 of { happy_var_6 -> + ( case happy_var_1 of + CDecl declspecs dies at -> do + declr <- withAsmNameAttrs (fst happy_var_5, snd happy_var_5 ++ happy_var_3) happy_var_4 + doDeclIdent declspecs declr + withLength at $ CDecl declspecs ((Just (reverseDeclr declr), happy_var_6, Nothing) : dies))}}}}} + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_96 = happySpecReduce_2 28# happyReduction_96 +happyReduction_96 happy_x_2 + happy_x_1 + = case happyOut64 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + happyIn35 + ((happy_var_1,happy_var_2) + )}} + +happyReduce_97 = happyMonadReduce 4# 29# happyReduction_97 +happyReduction_97 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_1 of { happy_var_1 -> + case happyOut63 happy_x_2 of { happy_var_2 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + case happyOut91 happy_x_4 of { happy_var_4 -> + ( do{ + declr <- withAsmNameAttrs happy_var_3 happy_var_2; + doDeclIdent happy_var_1 declr; + withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr declr), happy_var_4, Nothing)] })}}}} + ) (\r -> happyReturn (happyIn36 r)) + +happyReduce_98 = happyMonadReduce 4# 29# happyReduction_98 +happyReduction_98 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut63 happy_x_2 of { happy_var_2 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + case happyOut91 happy_x_4 of { happy_var_4 -> + ( do{ + declr <- withAsmNameAttrs happy_var_3 happy_var_2; + doDeclIdent happy_var_1 declr; + withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr declr), happy_var_4, Nothing)] })}}}} + ) (\r -> happyReturn (happyIn36 r)) + +happyReduce_99 = happyMonadReduce 6# 29# happyReduction_99 +happyReduction_99 (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) tk + = happyThen (case happyOut36 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + case happyOut63 happy_x_4 of { happy_var_4 -> + case happyOut35 happy_x_5 of { happy_var_5 -> + case happyOut91 happy_x_6 of { happy_var_6 -> + ( case happy_var_1 of + CDecl declspecs dies at -> do + declr <- withAsmNameAttrs (fst happy_var_5, snd happy_var_5 ++ happy_var_3) happy_var_4 + doDeclIdent declspecs declr + return (CDecl declspecs ((Just (reverseDeclr declr), happy_var_6, Nothing) : dies) at))}}}}} + ) (\r -> happyReturn (happyIn36 r)) + +happyReduce_100 = happySpecReduce_1 30# happyReduction_100 +happyReduction_100 happy_x_1 + = case happyOut43 happy_x_1 of { happy_var_1 -> + happyIn37 + (reverse happy_var_1 + )} + +happyReduce_101 = happySpecReduce_1 30# happyReduction_101 +happyReduction_101 happy_x_1 + = case happyOut45 happy_x_1 of { happy_var_1 -> + happyIn37 + (reverse happy_var_1 + )} + +happyReduce_102 = happySpecReduce_1 30# happyReduction_102 +happyReduction_102 happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + happyIn37 + (reverse happy_var_1 + )} + +happyReduce_103 = happySpecReduce_1 31# happyReduction_103 +happyReduction_103 happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + happyIn38 + (singleton (CStorageSpec happy_var_1) + )} + +happyReduce_104 = happySpecReduce_2 31# happyReduction_104 +happyReduction_104 happy_x_2 + happy_x_1 + = case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut40 happy_x_2 of { happy_var_2 -> + happyIn38 + (reverseList (liftCAttrs happy_var_1) `snoc` (CStorageSpec happy_var_2) + )}} + +happyReduce_105 = happySpecReduce_2 31# happyReduction_105 +happyReduction_105 happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut40 happy_x_2 of { happy_var_2 -> + happyIn38 + (rmap CTypeQual happy_var_1 `snoc` CStorageSpec happy_var_2 + )}} + +happyReduce_106 = happySpecReduce_3 31# happyReduction_106 +happyReduction_106 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut40 happy_x_3 of { happy_var_3 -> + happyIn38 + ((rmap CTypeQual happy_var_1 `rappend` liftCAttrs happy_var_2) `snoc` CStorageSpec happy_var_3 + )}}} + +happyReduce_107 = happySpecReduce_2 31# happyReduction_107 +happyReduction_107 happy_x_2 + happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_2 of { happy_var_2 -> + happyIn38 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_108 = happySpecReduce_2 31# happyReduction_108 +happyReduction_108 happy_x_2 + happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn38 + (addTrailingAttrs happy_var_1 happy_var_2 + )}} + +happyReduce_109 = happySpecReduce_1 32# happyReduction_109 +happyReduction_109 happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + happyIn39 + (CStorageSpec happy_var_1 + )} + +happyReduce_110 = happySpecReduce_1 32# happyReduction_110 +happyReduction_110 happy_x_1 + = case happyOut61 happy_x_1 of { happy_var_1 -> + happyIn39 + (CTypeQual happy_var_1 + )} + +happyReduce_111 = happyMonadReduce 1# 33# happyReduction_111 +happyReduction_111 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CTypedef)} + ) (\r -> happyReturn (happyIn40 r)) + +happyReduce_112 = happyMonadReduce 1# 33# happyReduction_112 +happyReduction_112 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CExtern)} + ) (\r -> happyReturn (happyIn40 r)) + +happyReduce_113 = happyMonadReduce 1# 33# happyReduction_113 +happyReduction_113 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CStatic)} + ) (\r -> happyReturn (happyIn40 r)) + +happyReduce_114 = happyMonadReduce 1# 33# happyReduction_114 +happyReduction_114 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CAuto)} + ) (\r -> happyReturn (happyIn40 r)) + +happyReduce_115 = happyMonadReduce 1# 33# happyReduction_115 +happyReduction_115 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CRegister)} + ) (\r -> happyReturn (happyIn40 r)) + +happyReduce_116 = happyMonadReduce 1# 33# happyReduction_116 +happyReduction_116 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CThread)} + ) (\r -> happyReturn (happyIn40 r)) + +happyReduce_117 = happySpecReduce_1 34# happyReduction_117 +happyReduction_117 happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + happyIn41 + (reverse happy_var_1 + )} + +happyReduce_118 = happySpecReduce_1 34# happyReduction_118 +happyReduction_118 happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + happyIn41 + (reverse happy_var_1 + )} + +happyReduce_119 = happySpecReduce_1 34# happyReduction_119 +happyReduction_119 happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + happyIn41 + (reverse happy_var_1 + )} + +happyReduce_120 = happyMonadReduce 1# 35# happyReduction_120 +happyReduction_120 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CVoidType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_121 = happyMonadReduce 1# 35# happyReduction_121 +happyReduction_121 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CCharType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_122 = happyMonadReduce 1# 35# happyReduction_122 +happyReduction_122 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CShortType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_123 = happyMonadReduce 1# 35# happyReduction_123 +happyReduction_123 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CIntType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_124 = happyMonadReduce 1# 35# happyReduction_124 +happyReduction_124 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CLongType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_125 = happyMonadReduce 1# 35# happyReduction_125 +happyReduction_125 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CFloatType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_126 = happyMonadReduce 1# 35# happyReduction_126 +happyReduction_126 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDoubleType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_127 = happyMonadReduce 1# 35# happyReduction_127 +happyReduction_127 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CSignedType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_128 = happyMonadReduce 1# 35# happyReduction_128 +happyReduction_128 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CUnsigType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_129 = happyMonadReduce 1# 35# happyReduction_129 +happyReduction_129 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CBoolType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_130 = happyMonadReduce 1# 35# happyReduction_130 +happyReduction_130 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CComplexType)} + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_131 = happySpecReduce_2 36# happyReduction_131 +happyReduction_131 happy_x_2 + happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_2 of { happy_var_2 -> + happyIn43 + (happy_var_1 `snoc` CTypeSpec happy_var_2 + )}} + +happyReduce_132 = happySpecReduce_2 36# happyReduction_132 +happyReduction_132 happy_x_2 + happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + case happyOut40 happy_x_2 of { happy_var_2 -> + happyIn43 + (happy_var_1 `snoc` CStorageSpec happy_var_2 + )}} + +happyReduce_133 = happySpecReduce_2 36# happyReduction_133 +happyReduction_133 happy_x_2 + happy_x_1 + = case happyOut43 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_2 of { happy_var_2 -> + happyIn43 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_134 = happySpecReduce_2 36# happyReduction_134 +happyReduction_134 happy_x_2 + happy_x_1 + = case happyOut43 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_2 of { happy_var_2 -> + happyIn43 + (happy_var_1 `snoc` CTypeSpec happy_var_2 + )}} + +happyReduce_135 = happySpecReduce_2 36# happyReduction_135 +happyReduction_135 happy_x_2 + happy_x_1 + = case happyOut43 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn43 + (addTrailingAttrs happy_var_1 happy_var_2 + )}} + +happyReduce_136 = happySpecReduce_1 37# happyReduction_136 +happyReduction_136 happy_x_1 + = case happyOut42 happy_x_1 of { happy_var_1 -> + happyIn44 + (singleton (CTypeSpec happy_var_1) + )} + +happyReduce_137 = happySpecReduce_2 37# happyReduction_137 +happyReduction_137 happy_x_2 + happy_x_1 + = case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_2 of { happy_var_2 -> + happyIn44 + ((reverseList $ liftCAttrs happy_var_1) `snoc` (CTypeSpec happy_var_2) + )}} + +happyReduce_138 = happySpecReduce_2 37# happyReduction_138 +happyReduction_138 happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_2 of { happy_var_2 -> + happyIn44 + (rmap CTypeQual happy_var_1 `snoc` CTypeSpec happy_var_2 + )}} + +happyReduce_139 = happySpecReduce_3 37# happyReduction_139 +happyReduction_139 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut42 happy_x_3 of { happy_var_3 -> + happyIn44 + (rmap CTypeQual happy_var_1 `rappend` (liftCAttrs happy_var_2) `snoc` CTypeSpec happy_var_3 + )}}} + +happyReduce_140 = happySpecReduce_2 37# happyReduction_140 +happyReduction_140 happy_x_2 + happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn44 + (happy_var_1 `snoc` CTypeQual happy_var_2 + )}} + +happyReduce_141 = happySpecReduce_2 37# happyReduction_141 +happyReduction_141 happy_x_2 + happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_2 of { happy_var_2 -> + happyIn44 + (happy_var_1 `snoc` CTypeSpec happy_var_2 + )}} + +happyReduce_142 = happySpecReduce_2 37# happyReduction_142 +happyReduction_142 happy_x_2 + happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn44 + (addTrailingAttrs happy_var_1 happy_var_2 + )}} + +happyReduce_143 = happySpecReduce_2 38# happyReduction_143 +happyReduction_143 happy_x_2 + happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn45 + (happy_var_1 `snoc` CTypeSpec happy_var_2 + )}} + +happyReduce_144 = happySpecReduce_2 38# happyReduction_144 +happyReduction_144 happy_x_2 + happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + case happyOut40 happy_x_2 of { happy_var_2 -> + happyIn45 + (happy_var_1 `snoc` CStorageSpec happy_var_2 + )}} + +happyReduce_145 = happySpecReduce_2 38# happyReduction_145 +happyReduction_145 happy_x_2 + happy_x_1 + = case happyOut45 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_2 of { happy_var_2 -> + happyIn45 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_146 = happySpecReduce_2 38# happyReduction_146 +happyReduction_146 happy_x_2 + happy_x_1 + = case happyOut45 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn45 + (addTrailingAttrs happy_var_1 happy_var_2 + )}} + +happyReduce_147 = happySpecReduce_1 39# happyReduction_147 +happyReduction_147 happy_x_1 + = case happyOut49 happy_x_1 of { happy_var_1 -> + happyIn46 + (singleton (CTypeSpec happy_var_1) + )} + +happyReduce_148 = happySpecReduce_2 39# happyReduction_148 +happyReduction_148 happy_x_2 + happy_x_1 + = case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn46 + ((reverseList $ liftCAttrs happy_var_1) `snoc` (CTypeSpec happy_var_2) + )}} + +happyReduce_149 = happySpecReduce_2 39# happyReduction_149 +happyReduction_149 happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn46 + (rmap CTypeQual happy_var_1 `snoc` CTypeSpec happy_var_2 + )}} + +happyReduce_150 = happySpecReduce_3 39# happyReduction_150 +happyReduction_150 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut49 happy_x_3 of { happy_var_3 -> + happyIn46 + (rmap CTypeQual happy_var_1 `rappend` (liftCAttrs happy_var_2) `snoc` CTypeSpec happy_var_3 + )}}} + +happyReduce_151 = happySpecReduce_2 39# happyReduction_151 +happyReduction_151 happy_x_2 + happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn46 + (happy_var_1 `snoc` CTypeQual happy_var_2 + )}} + +happyReduce_152 = happySpecReduce_2 39# happyReduction_152 +happyReduction_152 happy_x_2 + happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn46 + (addTrailingAttrs happy_var_1 happy_var_2 + )}} + +happyReduce_153 = happySpecReduce_2 40# happyReduction_153 +happyReduction_153 happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut40 happy_x_2 of { happy_var_2 -> + happyIn47 + (happy_var_1 `snoc` CStorageSpec happy_var_2 + )}} + +happyReduce_154 = happyMonadReduce 2# 40# happyReduction_154 +happyReduction_154 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (CTokTyIdent _ happy_var_2) -> + ( withNodeInfo happy_var_2 $ \at -> happy_var_1 `snoc` CTypeSpec (CTypeDef happy_var_2 at))}} + ) (\r -> happyReturn (happyIn47 r)) + +happyReduce_155 = happyMonadReduce 5# 40# happyReduction_155 +happyReduction_155 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut117 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_2 $ \at -> happy_var_1 `snoc` CTypeSpec (CTypeOfExpr happy_var_4 at))}}} + ) (\r -> happyReturn (happyIn47 r)) + +happyReduce_156 = happyMonadReduce 5# 40# happyReduction_156 +happyReduction_156 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut83 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_2 $ \at -> happy_var_1 `snoc` CTypeSpec (CTypeOfType happy_var_4 at))}}} + ) (\r -> happyReturn (happyIn47 r)) + +happyReduce_157 = happySpecReduce_2 40# happyReduction_157 +happyReduction_157 happy_x_2 + happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_2 of { happy_var_2 -> + happyIn47 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_158 = happySpecReduce_2 40# happyReduction_158 +happyReduction_158 happy_x_2 + happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn47 + (addTrailingAttrs happy_var_1 happy_var_2 + )}} + +happyReduce_159 = happyMonadReduce 1# 41# happyReduction_159 +happyReduction_159 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokTyIdent _ happy_var_1) -> + ( withNodeInfo happy_var_1 $ \at -> singleton (CTypeSpec (CTypeDef happy_var_1 at)))} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_160 = happyMonadReduce 4# 41# happyReduction_160 +happyReduction_160 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ \at -> singleton (CTypeSpec (CTypeOfExpr happy_var_3 at)))}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_161 = happyMonadReduce 4# 41# happyReduction_161 +happyReduction_161 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ \at -> singleton (CTypeSpec (CTypeOfType happy_var_3 at)))}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_162 = happyMonadReduce 2# 41# happyReduction_162 +happyReduction_162 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (CTokTyIdent _ happy_var_2) -> + ( withNodeInfo happy_var_2 $ \at -> rmap CTypeQual happy_var_1 `snoc` CTypeSpec (CTypeDef happy_var_2 at))}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_163 = happyMonadReduce 5# 41# happyReduction_163 +happyReduction_163 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut117 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_2 $ \at -> rmap CTypeQual happy_var_1 `snoc` CTypeSpec (CTypeOfExpr happy_var_4 at))}}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_164 = happyMonadReduce 5# 41# happyReduction_164 +happyReduction_164 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut83 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_2 $ \at -> rmap CTypeQual happy_var_1 `snoc` CTypeSpec (CTypeOfType happy_var_4 at))}}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_165 = happyMonadReduce 2# 41# happyReduction_165 +happyReduction_165 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (CTokTyIdent _ happy_var_2) -> + ( withNodeInfo happy_var_2 $ \at -> reverseList (liftCAttrs happy_var_1) `snoc` (CTypeSpec (CTypeDef happy_var_2 at)))}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_166 = happyMonadReduce 5# 41# happyReduction_166 +happyReduction_166 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ \at -> reverseList (liftCAttrs happy_var_1) `snoc` (CTypeSpec (CTypeOfExpr happy_var_4 at)))}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_167 = happyMonadReduce 5# 41# happyReduction_167 +happyReduction_167 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut83 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_2 $ \at -> reverseList (liftCAttrs happy_var_1) `snoc` (CTypeSpec (CTypeOfType happy_var_4 at)))}}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_168 = happyMonadReduce 3# 41# happyReduction_168 +happyReduction_168 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { (CTokTyIdent _ happy_var_3) -> + ( withNodeInfo happy_var_3 $ \at -> rmap CTypeQual happy_var_1 `rappend` (liftCAttrs happy_var_2) `snoc` CTypeSpec (CTypeDef happy_var_3 at))}}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_169 = happyMonadReduce 6# 41# happyReduction_169 +happyReduction_169 (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) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut117 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_3 $ \at -> rmap CTypeQual happy_var_1 `rappend` (liftCAttrs happy_var_2) `snoc` CTypeSpec (CTypeOfExpr happy_var_5 at))}}}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_170 = happyMonadReduce 6# 41# happyReduction_170 +happyReduction_170 (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) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + case happyOut83 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_3 $ \at -> rmap CTypeQual happy_var_1 `rappend` (liftCAttrs happy_var_2) `snoc` CTypeSpec (CTypeOfType happy_var_5 at))}}}} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_171 = happySpecReduce_2 41# happyReduction_171 +happyReduction_171 happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn48 + (happy_var_1 `snoc` CTypeQual happy_var_2 + )}} + +happyReduce_172 = happySpecReduce_2 41# happyReduction_172 +happyReduction_172 happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn48 + (addTrailingAttrs happy_var_1 happy_var_2 + )}} + +happyReduce_173 = happyMonadReduce 1# 42# happyReduction_173 +happyReduction_173 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut50 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CSUType happy_var_1)} + ) (\r -> happyReturn (happyIn49 r)) + +happyReduce_174 = happyMonadReduce 1# 42# happyReduction_174 +happyReduction_174 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut58 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CEnumType happy_var_1)} + ) (\r -> happyReturn (happyIn49 r)) + +happyReduce_175 = happyMonadReduce 6# 43# happyReduction_175 +happyReduction_175 (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) tk + = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + case happyOut52 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CStruct (unL happy_var_1) (Just happy_var_3) (Just$ reverse happy_var_5) happy_var_2)}}}} + ) (\r -> happyReturn (happyIn50 r)) + +happyReduce_176 = happyMonadReduce 5# 43# happyReduction_176 +happyReduction_176 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CStruct (unL happy_var_1) Nothing (Just$ reverse happy_var_4) happy_var_2)}}} + ) (\r -> happyReturn (happyIn50 r)) + +happyReduce_177 = happyMonadReduce 3# 43# happyReduction_177 +happyReduction_177 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CStruct (unL happy_var_1) (Just happy_var_3) Nothing happy_var_2)}}} + ) (\r -> happyReturn (happyIn50 r)) + +happyReduce_178 = happySpecReduce_1 44# happyReduction_178 +happyReduction_178 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn51 + (L CStructTag (posOf happy_var_1) + )} + +happyReduce_179 = happySpecReduce_1 44# happyReduction_179 +happyReduction_179 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn51 + (L CUnionTag (posOf happy_var_1) + )} + +happyReduce_180 = happySpecReduce_0 45# happyReduction_180 +happyReduction_180 = happyIn52 + (empty + ) + +happyReduce_181 = happySpecReduce_2 45# happyReduction_181 +happyReduction_181 happy_x_2 + happy_x_1 + = case happyOut52 happy_x_1 of { happy_var_1 -> + happyIn52 + (happy_var_1 + )} + +happyReduce_182 = happySpecReduce_2 45# happyReduction_182 +happyReduction_182 happy_x_2 + happy_x_1 + = case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_2 of { happy_var_2 -> + happyIn52 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_183 = happySpecReduce_2 46# happyReduction_183 +happyReduction_183 happy_x_2 + happy_x_1 + = case happyOut55 happy_x_1 of { happy_var_1 -> + happyIn53 + (case happy_var_1 of CDecl declspecs dies at -> CDecl declspecs (List.reverse dies) at + )} + +happyReduce_184 = happySpecReduce_2 46# happyReduction_184 +happyReduction_184 happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + happyIn53 + (case happy_var_1 of CDecl declspecs dies at -> CDecl declspecs (List.reverse dies) at + )} + +happyReduce_185 = happySpecReduce_2 46# happyReduction_185 +happyReduction_185 happy_x_2 + happy_x_1 + = case happyOut53 happy_x_2 of { happy_var_2 -> + happyIn53 + (happy_var_2 + )} + +happyReduce_186 = happyMonadReduce 3# 47# happyReduction_186 +happyReduction_186 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut57 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ case happy_var_3 of (d,s) -> CDecl (liftTypeQuals happy_var_1 ++ liftCAttrs happy_var_2) [(d,Nothing,s)])}}} + ) (\r -> happyReturn (happyIn54 r)) + +happyReduce_187 = happyMonadReduce 2# 47# happyReduction_187 +happyReduction_187 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut57 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ case happy_var_2 of (d,s) -> CDecl (liftCAttrs happy_var_1) [(d,Nothing,s)])}} + ) (\r -> happyReturn (happyIn54 r)) + +happyReduce_188 = happyReduce 4# 47# happyReduction_188 +happyReduction_188 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + case happyOut57 happy_x_4 of { happy_var_4 -> + happyIn54 + (case happy_var_1 of + CDecl declspecs dies at -> + case happy_var_4 of + (Just d,s) -> CDecl declspecs ((Just $ appendObjAttrs happy_var_3 d,Nothing,s) : dies) at + (Nothing,s) -> CDecl declspecs ((Nothing,Nothing,s) : dies) at + ) `HappyStk` happyRest}}} + +happyReduce_189 = happyMonadReduce 3# 48# happyReduction_189 +happyReduction_189 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut56 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ case happy_var_2 of { (Just d,s) -> CDecl happy_var_1 [(Just $! appendObjAttrs happy_var_3 d,Nothing,s)] + ; (Nothing,s) -> CDecl happy_var_1 [(Nothing,Nothing,s)] })}}} + ) (\r -> happyReturn (happyIn55 r)) + +happyReduce_190 = happyReduce 5# 48# happyReduction_190 +happyReduction_190 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut55 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + case happyOut56 happy_x_4 of { happy_var_4 -> + case happyOut126 happy_x_5 of { happy_var_5 -> + happyIn55 + (case happy_var_1 of + CDecl declspecs dies attr -> + case happy_var_4 of + (Just d,s) -> CDecl declspecs ((Just$ appendObjAttrs (happy_var_3++happy_var_5) d,Nothing,s) : dies) attr + (Nothing,s) -> CDecl declspecs ((Nothing,Nothing,s) : dies) attr + ) `HappyStk` happyRest}}}} + +happyReduce_191 = happyMonadReduce 1# 48# happyReduction_191 +happyReduction_191 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [])} + ) (\r -> happyReturn (happyIn55 r)) + +happyReduce_192 = happySpecReduce_1 49# happyReduction_192 +happyReduction_192 happy_x_1 + = case happyOut63 happy_x_1 of { happy_var_1 -> + happyIn56 + ((Just (reverseDeclr happy_var_1), Nothing) + )} + +happyReduce_193 = happySpecReduce_2 49# happyReduction_193 +happyReduction_193 happy_x_2 + happy_x_1 + = case happyOut121 happy_x_2 of { happy_var_2 -> + happyIn56 + ((Nothing, Just happy_var_2) + )} + +happyReduce_194 = happySpecReduce_3 49# happyReduction_194 +happyReduction_194 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut63 happy_x_1 of { happy_var_1 -> + case happyOut121 happy_x_3 of { happy_var_3 -> + happyIn56 + ((Just (reverseDeclr happy_var_1), Just happy_var_3) + )}} + +happyReduce_195 = happySpecReduce_1 50# happyReduction_195 +happyReduction_195 happy_x_1 + = case happyOut72 happy_x_1 of { happy_var_1 -> + happyIn57 + ((Just (reverseDeclr happy_var_1), Nothing) + )} + +happyReduce_196 = happySpecReduce_2 50# happyReduction_196 +happyReduction_196 happy_x_2 + happy_x_1 + = case happyOut121 happy_x_2 of { happy_var_2 -> + happyIn57 + ((Nothing, Just happy_var_2) + )} + +happyReduce_197 = happySpecReduce_3 50# happyReduction_197 +happyReduction_197 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOut121 happy_x_3 of { happy_var_3 -> + happyIn57 + ((Just (reverseDeclr happy_var_1), Just happy_var_3) + )}} + +happyReduce_198 = happySpecReduce_2 50# happyReduction_198 +happyReduction_198 happy_x_2 + happy_x_1 + = case happyOut57 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn57 + (case happy_var_1 of { (Nothing,expr) -> (Nothing,expr) {- FIXME -} + ; (Just (CDeclr name derived asmname attrs node), bsz) -> + (Just (CDeclr name derived asmname (attrs++happy_var_2) node),bsz) + } + )}} + +happyReduce_199 = happyMonadReduce 5# 51# happyReduction_199 +happyReduction_199 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut59 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CEnum Nothing (Just$ reverse happy_var_4) happy_var_2)}}} + ) (\r -> happyReturn (happyIn58 r)) + +happyReduce_200 = happyMonadReduce 6# 51# happyReduction_200 +happyReduction_200 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut59 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CEnum Nothing (Just$ reverse happy_var_4) happy_var_2)}}} + ) (\r -> happyReturn (happyIn58 r)) + +happyReduce_201 = happyMonadReduce 6# 51# happyReduction_201 +happyReduction_201 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + case happyOut59 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CEnum (Just happy_var_3) (Just$ reverse happy_var_5) happy_var_2)}}}} + ) (\r -> happyReturn (happyIn58 r)) + +happyReduce_202 = happyMonadReduce 7# 51# happyReduction_202 +happyReduction_202 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + case happyOut59 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CEnum (Just happy_var_3) (Just$ reverse happy_var_5) happy_var_2)}}}} + ) (\r -> happyReturn (happyIn58 r)) + +happyReduce_203 = happyMonadReduce 3# 51# happyReduction_203 +happyReduction_203 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CEnum (Just happy_var_3) Nothing happy_var_2)}}} + ) (\r -> happyReturn (happyIn58 r)) + +happyReduce_204 = happySpecReduce_1 52# happyReduction_204 +happyReduction_204 happy_x_1 + = case happyOut60 happy_x_1 of { happy_var_1 -> + happyIn59 + (singleton happy_var_1 + )} + +happyReduce_205 = happySpecReduce_3 52# happyReduction_205 +happyReduction_205 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut59 happy_x_1 of { happy_var_1 -> + case happyOut60 happy_x_3 of { happy_var_3 -> + happyIn59 + (happy_var_1 `snoc` happy_var_3 + )}} + +happyReduce_206 = happySpecReduce_1 53# happyReduction_206 +happyReduction_206 happy_x_1 + = case happyOut125 happy_x_1 of { happy_var_1 -> + happyIn60 + ((happy_var_1, Nothing) + )} + +happyReduce_207 = happySpecReduce_3 53# happyReduction_207 +happyReduction_207 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut125 happy_x_1 of { happy_var_1 -> + case happyOut121 happy_x_3 of { happy_var_3 -> + happyIn60 + ((happy_var_1, Just happy_var_3) + )}} + +happyReduce_208 = happyMonadReduce 1# 54# happyReduction_208 +happyReduction_208 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CConstQual)} + ) (\r -> happyReturn (happyIn61 r)) + +happyReduce_209 = happyMonadReduce 1# 54# happyReduction_209 +happyReduction_209 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CVolatQual)} + ) (\r -> happyReturn (happyIn61 r)) + +happyReduce_210 = happyMonadReduce 1# 54# happyReduction_210 +happyReduction_210 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CRestrQual)} + ) (\r -> happyReturn (happyIn61 r)) + +happyReduce_211 = happyMonadReduce 1# 54# happyReduction_211 +happyReduction_211 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CInlineQual)} + ) (\r -> happyReturn (happyIn61 r)) + +happyReduce_212 = happySpecReduce_2 55# happyReduction_212 +happyReduction_212 happy_x_2 + happy_x_1 + = case happyOut126 happy_x_1 of { happy_var_1 -> + case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn62 + (reverseList (map CAttrQual happy_var_1) `snoc` happy_var_2 + )}} + +happyReduce_213 = happySpecReduce_2 55# happyReduction_213 +happyReduction_213 happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn62 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_214 = happySpecReduce_3 55# happyReduction_214 +happyReduction_214 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut61 happy_x_3 of { happy_var_3 -> + happyIn62 + ((happy_var_1 `rappend` map CAttrQual happy_var_2) `snoc` happy_var_3 + )}}} + +happyReduce_215 = happySpecReduce_1 56# happyReduction_215 +happyReduction_215 happy_x_1 + = case happyOut72 happy_x_1 of { happy_var_1 -> + happyIn63 + (happy_var_1 + )} + +happyReduce_216 = happySpecReduce_1 56# happyReduction_216 +happyReduction_216 happy_x_1 + = case happyOut65 happy_x_1 of { happy_var_1 -> + happyIn63 + (happy_var_1 + )} + +happyReduce_217 = happySpecReduce_0 57# happyReduction_217 +happyReduction_217 = happyIn64 + (Nothing + ) + +happyReduce_218 = happyReduce 4# 57# happyReduction_218 +happyReduction_218 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut123 happy_x_3 of { happy_var_3 -> + happyIn64 + (Just happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_219 = happySpecReduce_1 58# happyReduction_219 +happyReduction_219 happy_x_1 + = case happyOut69 happy_x_1 of { happy_var_1 -> + happyIn65 + (happy_var_1 + )} + +happyReduce_220 = happySpecReduce_1 58# happyReduction_220 +happyReduction_220 happy_x_1 + = case happyOut66 happy_x_1 of { happy_var_1 -> + happyIn65 + (happy_var_1 + )} + +happyReduce_221 = happyMonadReduce 1# 59# happyReduction_221 +happyReduction_221 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokTyIdent _ happy_var_1) -> + ( withNodeInfo happy_var_1 $ mkVarDeclr happy_var_1)} + ) (\r -> happyReturn (happyIn66 r)) + +happyReduce_222 = happyMonadReduce 2# 59# happyReduction_222 +happyReduction_222 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokTyIdent _ happy_var_1) -> + case happyOut85 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ \at -> happy_var_2 (mkVarDeclr happy_var_1 at))}} + ) (\r -> happyReturn (happyIn66 r)) + +happyReduce_223 = happySpecReduce_1 59# happyReduction_223 +happyReduction_223 happy_x_1 + = case happyOut67 happy_x_1 of { happy_var_1 -> + happyIn66 + (happy_var_1 + )} + +happyReduce_224 = happySpecReduce_1 60# happyReduction_224 +happyReduction_224 happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn67 + (happy_var_1 + )} + +happyReduce_225 = happyMonadReduce 2# 60# happyReduction_225 +happyReduction_225 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_2 [])}} + ) (\r -> happyReturn (happyIn67 r)) + +happyReduce_226 = happyMonadReduce 3# 60# happyReduction_226 +happyReduction_226 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut66 happy_x_3 of { happy_var_3 -> + ( withAttribute happy_var_1 happy_var_2 $ ptrDeclr happy_var_3 [])}}} + ) (\r -> happyReturn (happyIn67 r)) + +happyReduce_227 = happyMonadReduce 3# 60# happyReduction_227 +happyReduction_227 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut66 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_3 (reverse happy_var_2))}}} + ) (\r -> happyReturn (happyIn67 r)) + +happyReduce_228 = happyMonadReduce 4# 60# happyReduction_228 +happyReduction_228 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut66 happy_x_4 of { happy_var_4 -> + ( withAttribute happy_var_1 happy_var_3 $ ptrDeclr happy_var_4 (reverse happy_var_2))}}}} + ) (\r -> happyReturn (happyIn67 r)) + +happyReduce_229 = happySpecReduce_3 61# happyReduction_229 +happyReduction_229 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut67 happy_x_2 of { happy_var_2 -> + happyIn68 + (happy_var_2 + )} + +happyReduce_230 = happyReduce 4# 61# happyReduction_230 +happyReduction_230 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut67 happy_x_2 of { happy_var_2 -> + case happyOut85 happy_x_4 of { happy_var_4 -> + happyIn68 + (happy_var_4 happy_var_2 + ) `HappyStk` happyRest}} + +happyReduce_231 = happyReduce 4# 61# happyReduction_231 +happyReduction_231 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut67 happy_x_3 of { happy_var_3 -> + happyIn68 + (appendDeclrAttrs happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_232 = happyReduce 5# 61# happyReduction_232 +happyReduction_232 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut67 happy_x_3 of { happy_var_3 -> + case happyOut85 happy_x_5 of { happy_var_5 -> + happyIn68 + (appendDeclrAttrs happy_var_2 (happy_var_5 happy_var_3) + ) `HappyStk` happyRest}}} + +happyReduce_233 = happySpecReduce_1 62# happyReduction_233 +happyReduction_233 happy_x_1 + = case happyOut70 happy_x_1 of { happy_var_1 -> + happyIn69 + (happy_var_1 + )} + +happyReduce_234 = happyMonadReduce 4# 62# happyReduction_234 +happyReduction_234 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut71 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_3 [])}} + ) (\r -> happyReturn (happyIn69 r)) + +happyReduce_235 = happyMonadReduce 5# 62# happyReduction_235 +happyReduction_235 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut71 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_4 (reverse happy_var_2))}}} + ) (\r -> happyReturn (happyIn69 r)) + +happyReduce_236 = happyMonadReduce 6# 62# happyReduction_236 +happyReduction_236 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut71 happy_x_5 of { happy_var_5 -> + ( withAttribute happy_var_1 happy_var_3 $ ptrDeclr happy_var_5 (reverse happy_var_2))}}}} + ) (\r -> happyReturn (happyIn69 r)) + +happyReduce_237 = happyMonadReduce 2# 62# happyReduction_237 +happyReduction_237 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut69 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_2 [])}} + ) (\r -> happyReturn (happyIn69 r)) + +happyReduce_238 = happyMonadReduce 3# 62# happyReduction_238 +happyReduction_238 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut69 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_3 (reverse happy_var_2))}}} + ) (\r -> happyReturn (happyIn69 r)) + +happyReduce_239 = happyMonadReduce 4# 62# happyReduction_239 +happyReduction_239 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut69 happy_x_4 of { happy_var_4 -> + ( withAttribute happy_var_1 happy_var_3 $ ptrDeclr happy_var_4 (reverse happy_var_2))}}}} + ) (\r -> happyReturn (happyIn69 r)) + +happyReduce_240 = happySpecReduce_3 63# happyReduction_240 +happyReduction_240 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut69 happy_x_2 of { happy_var_2 -> + happyIn70 + (happy_var_2 + )} + +happyReduce_241 = happyReduce 4# 63# happyReduction_241 +happyReduction_241 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut71 happy_x_2 of { happy_var_2 -> + case happyOut85 happy_x_3 of { happy_var_3 -> + happyIn70 + (happy_var_3 happy_var_2 + ) `HappyStk` happyRest}} + +happyReduce_242 = happyReduce 4# 63# happyReduction_242 +happyReduction_242 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut69 happy_x_2 of { happy_var_2 -> + case happyOut85 happy_x_4 of { happy_var_4 -> + happyIn70 + (happy_var_4 happy_var_2 + ) `HappyStk` happyRest}} + +happyReduce_243 = happyMonadReduce 1# 64# happyReduction_243 +happyReduction_243 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokTyIdent _ happy_var_1) -> + ( withNodeInfo happy_var_1 $ mkVarDeclr happy_var_1)} + ) (\r -> happyReturn (happyIn71 r)) + +happyReduce_244 = happySpecReduce_3 64# happyReduction_244 +happyReduction_244 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut71 happy_x_2 of { happy_var_2 -> + happyIn71 + (happy_var_2 + )} + +happyReduce_245 = happySpecReduce_1 65# happyReduction_245 +happyReduction_245 happy_x_1 + = case happyOut73 happy_x_1 of { happy_var_1 -> + happyIn72 + (happy_var_1 + )} + +happyReduce_246 = happySpecReduce_1 65# happyReduction_246 +happyReduction_246 happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + happyIn72 + (happy_var_1 + )} + +happyReduce_247 = happySpecReduce_1 66# happyReduction_247 +happyReduction_247 happy_x_1 + = case happyOut74 happy_x_1 of { happy_var_1 -> + happyIn73 + (happy_var_1 + )} + +happyReduce_248 = happyMonadReduce 2# 66# happyReduction_248 +happyReduction_248 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_2 [])}} + ) (\r -> happyReturn (happyIn73 r)) + +happyReduce_249 = happyMonadReduce 3# 66# happyReduction_249 +happyReduction_249 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut72 happy_x_3 of { happy_var_3 -> + ( withAttribute happy_var_1 happy_var_2 $ ptrDeclr happy_var_3 [])}}} + ) (\r -> happyReturn (happyIn73 r)) + +happyReduce_250 = happyMonadReduce 3# 66# happyReduction_250 +happyReduction_250 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut72 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_3 (reverse happy_var_2))}}} + ) (\r -> happyReturn (happyIn73 r)) + +happyReduce_251 = happyMonadReduce 4# 66# happyReduction_251 +happyReduction_251 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut72 happy_x_4 of { happy_var_4 -> + ( withAttribute happy_var_1 happy_var_3 $ ptrDeclr happy_var_4 (reverse happy_var_2))}}}} + ) (\r -> happyReturn (happyIn73 r)) + +happyReduce_252 = happySpecReduce_2 67# happyReduction_252 +happyReduction_252 happy_x_2 + happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut85 happy_x_2 of { happy_var_2 -> + happyIn74 + (happy_var_2 happy_var_1 + )}} + +happyReduce_253 = happySpecReduce_3 67# happyReduction_253 +happyReduction_253 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut73 happy_x_2 of { happy_var_2 -> + happyIn74 + (happy_var_2 + )} + +happyReduce_254 = happyReduce 4# 67# happyReduction_254 +happyReduction_254 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut73 happy_x_2 of { happy_var_2 -> + case happyOut85 happy_x_4 of { happy_var_4 -> + happyIn74 + (happy_var_4 happy_var_2 + ) `HappyStk` happyRest}} + +happyReduce_255 = happyReduce 4# 67# happyReduction_255 +happyReduction_255 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + happyIn74 + (appendDeclrAttrs happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_256 = happyReduce 5# 67# happyReduction_256 +happyReduction_256 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + case happyOut85 happy_x_5 of { happy_var_5 -> + happyIn74 + (appendDeclrAttrs happy_var_2 (happy_var_5 happy_var_3) + ) `HappyStk` happyRest}}} + +happyReduce_257 = happyMonadReduce 1# 68# happyReduction_257 +happyReduction_257 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokIdent _ happy_var_1) -> + ( withNodeInfo happy_var_1 $ mkVarDeclr happy_var_1)} + ) (\r -> happyReturn (happyIn75 r)) + +happyReduce_258 = happySpecReduce_3 68# happyReduction_258 +happyReduction_258 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut75 happy_x_2 of { happy_var_2 -> + happyIn75 + (happy_var_2 + )} + +happyReduce_259 = happyReduce 4# 68# happyReduction_259 +happyReduction_259 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut75 happy_x_3 of { happy_var_3 -> + happyIn75 + (appendDeclrAttrs happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_260 = happySpecReduce_1 69# happyReduction_260 +happyReduction_260 happy_x_1 + = case happyOut77 happy_x_1 of { happy_var_1 -> + happyIn76 + (reverseDeclr happy_var_1 + )} + +happyReduce_261 = happySpecReduce_1 70# happyReduction_261 +happyReduction_261 happy_x_1 + = case happyOut78 happy_x_1 of { happy_var_1 -> + happyIn77 + (happy_var_1 + )} + +happyReduce_262 = happyMonadReduce 2# 70# happyReduction_262 +happyReduction_262 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut77 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_2 [])}} + ) (\r -> happyReturn (happyIn77 r)) + +happyReduce_263 = happyMonadReduce 3# 70# happyReduction_263 +happyReduction_263 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut77 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_3 (reverse happy_var_2))}}} + ) (\r -> happyReturn (happyIn77 r)) + +happyReduce_264 = happyMonadReduce 4# 71# happyReduction_264 +happyReduction_264 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ funDeclr happy_var_1 (Left $ reverse happy_var_3) [])}} + ) (\r -> happyReturn (happyIn78 r)) + +happyReduce_265 = happySpecReduce_3 71# happyReduction_265 +happyReduction_265 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut77 happy_x_2 of { happy_var_2 -> + happyIn78 + (happy_var_2 + )} + +happyReduce_266 = happyReduce 4# 71# happyReduction_266 +happyReduction_266 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut77 happy_x_2 of { happy_var_2 -> + case happyOut85 happy_x_4 of { happy_var_4 -> + happyIn78 + (happy_var_4 happy_var_2 + ) `HappyStk` happyRest}} + +happyReduce_267 = happySpecReduce_0 72# happyReduction_267 +happyReduction_267 = happyIn79 + (([], False) + ) + +happyReduce_268 = happySpecReduce_1 72# happyReduction_268 +happyReduction_268 happy_x_1 + = case happyOut80 happy_x_1 of { happy_var_1 -> + happyIn79 + ((reverse happy_var_1, False) + )} + +happyReduce_269 = happySpecReduce_3 72# happyReduction_269 +happyReduction_269 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut80 happy_x_1 of { happy_var_1 -> + happyIn79 + ((reverse happy_var_1, True) + )} + +happyReduce_270 = happySpecReduce_1 73# happyReduction_270 +happyReduction_270 happy_x_1 + = case happyOut81 happy_x_1 of { happy_var_1 -> + happyIn80 + (singleton happy_var_1 + )} + +happyReduce_271 = happySpecReduce_3 73# happyReduction_271 +happyReduction_271 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut80 happy_x_1 of { happy_var_1 -> + case happyOut81 happy_x_3 of { happy_var_3 -> + happyIn80 + (happy_var_1 `snoc` happy_var_3 + )}} + +happyReduce_272 = happyMonadReduce 1# 74# happyReduction_272 +happyReduction_272 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [])} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_273 = happyMonadReduce 2# 74# happyReduction_273 +happyReduction_273 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr happy_var_2), Nothing, Nothing)])}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_274 = happyMonadReduce 3# 74# happyReduction_274 +happyReduction_274 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr $! appendDeclrAttrs happy_var_3 happy_var_2), Nothing, Nothing)])}}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_275 = happyMonadReduce 3# 74# happyReduction_275 +happyReduction_275 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut37 happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr $! appendDeclrAttrs happy_var_3 happy_var_2), Nothing, Nothing)])}}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_276 = happyMonadReduce 1# 74# happyReduction_276 +happyReduction_276 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDecl (reverse happy_var_1) [])} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_277 = happyMonadReduce 2# 74# happyReduction_277 +happyReduction_277 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CDecl (reverse happy_var_1) [(Just (reverseDeclr happy_var_2), Nothing, Nothing)])}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_278 = happyMonadReduce 3# 74# happyReduction_278 +happyReduction_278 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CDecl (reverse happy_var_1) [(Just (reverseDeclr $! appendDeclrAttrs happy_var_3 happy_var_2), Nothing, Nothing)])}}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_279 = happyMonadReduce 1# 74# happyReduction_279 +happyReduction_279 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [])} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_280 = happyMonadReduce 2# 74# happyReduction_280 +happyReduction_280 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr happy_var_2), Nothing, Nothing)])}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_281 = happyMonadReduce 3# 74# happyReduction_281 +happyReduction_281 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr $! appendDeclrAttrs happy_var_3 happy_var_2), Nothing, Nothing)])}}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_282 = happyMonadReduce 3# 74# happyReduction_282 +happyReduction_282 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr $! appendDeclrAttrs happy_var_3 happy_var_2), Nothing, Nothing)])}}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_283 = happyMonadReduce 1# 74# happyReduction_283 +happyReduction_283 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDecl (liftTypeQuals happy_var_1) [])} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_284 = happyMonadReduce 2# 74# happyReduction_284 +happyReduction_284 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CDecl (liftTypeQuals happy_var_1 ++ liftCAttrs happy_var_2) [])}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_285 = happyMonadReduce 2# 74# happyReduction_285 +happyReduction_285 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CDecl (liftTypeQuals happy_var_1) [(Just (reverseDeclr happy_var_2), Nothing, Nothing)])}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_286 = happyMonadReduce 3# 74# happyReduction_286 +happyReduction_286 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CDecl (liftTypeQuals happy_var_1) [(Just (reverseDeclr$ appendDeclrAttrs happy_var_3 happy_var_2), Nothing, Nothing)])}}} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_287 = happySpecReduce_1 75# happyReduction_287 +happyReduction_287 happy_x_1 + = case happyOutTok happy_x_1 of { (CTokIdent _ happy_var_1) -> + happyIn82 + (singleton happy_var_1 + )} + +happyReduce_288 = happySpecReduce_3 75# happyReduction_288 +happyReduction_288 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { (CTokIdent _ happy_var_3) -> + happyIn82 + (happy_var_1 `snoc` happy_var_3 + )}} + +happyReduce_289 = happyMonadReduce 1# 76# happyReduction_289 +happyReduction_289 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [])} + ) (\r -> happyReturn (happyIn83 r)) + +happyReduce_290 = happyMonadReduce 2# 76# happyReduction_290 +happyReduction_290 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CDecl happy_var_1 [(Just (reverseDeclr happy_var_2), Nothing, Nothing)])}} + ) (\r -> happyReturn (happyIn83 r)) + +happyReduce_291 = happyMonadReduce 2# 76# happyReduction_291 +happyReduction_291 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CDecl (liftTypeQuals happy_var_1 ++ liftCAttrs happy_var_2) [])}} + ) (\r -> happyReturn (happyIn83 r)) + +happyReduce_292 = happyMonadReduce 2# 76# happyReduction_292 +happyReduction_292 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CDecl (liftTypeQuals happy_var_1) [(Just (reverseDeclr happy_var_2), Nothing, Nothing)])}} + ) (\r -> happyReturn (happyIn83 r)) + +happyReduce_293 = happySpecReduce_1 77# happyReduction_293 +happyReduction_293 happy_x_1 + = case happyOut88 happy_x_1 of { happy_var_1 -> + happyIn84 + (happy_var_1 + )} + +happyReduce_294 = happySpecReduce_1 77# happyReduction_294 +happyReduction_294 happy_x_1 + = case happyOut89 happy_x_1 of { happy_var_1 -> + happyIn84 + (happy_var_1 + )} + +happyReduce_295 = happySpecReduce_1 77# happyReduction_295 +happyReduction_295 happy_x_1 + = case happyOut85 happy_x_1 of { happy_var_1 -> + happyIn84 + (happy_var_1 emptyDeclr + )} + +happyReduce_296 = happySpecReduce_1 78# happyReduction_296 +happyReduction_296 happy_x_1 + = case happyOut86 happy_x_1 of { happy_var_1 -> + happyIn85 + (happy_var_1 + )} + +happyReduce_297 = happyMonadReduce 3# 78# happyReduction_297 +happyReduction_297 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut79 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ \at declr -> case happy_var_2 of + (params, variadic) -> funDeclr declr (Right (params,variadic)) [] at)}} + ) (\r -> happyReturn (happyIn85 r)) + +happyReduce_298 = happySpecReduce_1 79# happyReduction_298 +happyReduction_298 happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn86 + (happy_var_1 + )} + +happyReduce_299 = happySpecReduce_2 79# happyReduction_299 +happyReduction_299 happy_x_2 + happy_x_1 + = case happyOut86 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_2 of { happy_var_2 -> + happyIn86 + (\decl -> happy_var_2 (happy_var_1 decl) + )}} + +happyReduce_300 = happyMonadReduce 3# 80# happyReduction_300 +happyReduction_300 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut120 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ \at declr -> arrDeclr declr [] False False happy_var_2 at)}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_301 = happyMonadReduce 4# 80# happyReduction_301 +happyReduction_301 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut120 happy_x_3 of { happy_var_3 -> + ( withAttributePF happy_var_1 happy_var_2 $ \at declr -> arrDeclr declr [] False False happy_var_3 at)}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_302 = happyMonadReduce 4# 80# happyReduction_302 +happyReduction_302 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut120 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ \at declr -> arrDeclr declr (reverse happy_var_2) False False happy_var_3 at)}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_303 = happyMonadReduce 5# 80# happyReduction_303 +happyReduction_303 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut120 happy_x_4 of { happy_var_4 -> + ( withAttributePF happy_var_1 happy_var_3 $ \at declr -> arrDeclr declr (reverse happy_var_2) False False happy_var_4 at)}}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_304 = happyMonadReduce 5# 80# happyReduction_304 +happyReduction_304 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + case happyOut115 happy_x_4 of { happy_var_4 -> + ( withAttributePF happy_var_1 happy_var_3 $ \at declr -> arrDeclr declr [] False True (Just happy_var_4) at)}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_305 = happyMonadReduce 6# 80# happyReduction_305 +happyReduction_305 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_3 of { happy_var_3 -> + case happyOut126 happy_x_4 of { happy_var_4 -> + case happyOut115 happy_x_5 of { happy_var_5 -> + ( withAttributePF happy_var_1 happy_var_4 $ \at declr -> arrDeclr declr (reverse happy_var_3) False True (Just happy_var_5) at)}}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_306 = happyMonadReduce 7# 80# happyReduction_306 +happyReduction_306 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + case happyOut126 happy_x_5 of { happy_var_5 -> + case happyOut115 happy_x_6 of { happy_var_6 -> + ( withAttributePF happy_var_1 (happy_var_3 ++ happy_var_5) $ \at declr -> arrDeclr declr (reverse happy_var_2) False True (Just happy_var_6) at)}}}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_307 = happyMonadReduce 4# 80# happyReduction_307 +happyReduction_307 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withAttributePF happy_var_1 happy_var_3 $ \at declr -> arrDeclr declr [] True False Nothing at)}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_308 = happyMonadReduce 5# 80# happyReduction_308 +happyReduction_308 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_4 of { happy_var_4 -> + ( withAttributePF happy_var_1 (happy_var_2 ++ happy_var_4) $ \at declr -> arrDeclr declr [] True False Nothing at)}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_309 = happyMonadReduce 5# 80# happyReduction_309 +happyReduction_309 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_4 of { happy_var_4 -> + ( withAttributePF happy_var_1 happy_var_4 $ \at declr -> arrDeclr declr (reverse happy_var_2) True False Nothing at)}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_310 = happyMonadReduce 6# 80# happyReduction_310 +happyReduction_310 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut126 happy_x_5 of { happy_var_5 -> + ( withAttributePF happy_var_1 (happy_var_3 ++ happy_var_5) $ \at declr -> arrDeclr declr (reverse happy_var_2) True False Nothing at)}}}} + ) (\r -> happyReturn (happyIn87 r)) + +happyReduce_311 = happyMonadReduce 1# 81# happyReduction_311 +happyReduction_311 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ ptrDeclr emptyDeclr [])} + ) (\r -> happyReturn (happyIn88 r)) + +happyReduce_312 = happyMonadReduce 3# 81# happyReduction_312 +happyReduction_312 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut126 happy_x_3 of { happy_var_3 -> + ( withAttribute happy_var_1 happy_var_3 $ ptrDeclr emptyDeclr (reverse happy_var_2))}}} + ) (\r -> happyReturn (happyIn88 r)) + +happyReduce_313 = happyMonadReduce 2# 81# happyReduction_313 +happyReduction_313 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_2 [])}} + ) (\r -> happyReturn (happyIn88 r)) + +happyReduce_314 = happyMonadReduce 3# 81# happyReduction_314 +happyReduction_314 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut84 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ ptrDeclr happy_var_3 (reverse happy_var_2))}}} + ) (\r -> happyReturn (happyIn88 r)) + +happyReduce_315 = happyMonadReduce 2# 81# happyReduction_315 +happyReduction_315 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + ( withAttribute happy_var_1 happy_var_2 $ ptrDeclr emptyDeclr [])}} + ) (\r -> happyReturn (happyIn88 r)) + +happyReduce_316 = happyMonadReduce 3# 81# happyReduction_316 +happyReduction_316 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut84 happy_x_3 of { happy_var_3 -> + ( withAttribute happy_var_1 happy_var_2 $ ptrDeclr happy_var_3 [])}}} + ) (\r -> happyReturn (happyIn88 r)) + +happyReduce_317 = happySpecReduce_3 82# happyReduction_317 +happyReduction_317 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut88 happy_x_2 of { happy_var_2 -> + happyIn89 + (happy_var_2 + )} + +happyReduce_318 = happySpecReduce_3 82# happyReduction_318 +happyReduction_318 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut89 happy_x_2 of { happy_var_2 -> + happyIn89 + (happy_var_2 + )} + +happyReduce_319 = happySpecReduce_3 82# happyReduction_319 +happyReduction_319 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut85 happy_x_2 of { happy_var_2 -> + happyIn89 + (happy_var_2 emptyDeclr + )} + +happyReduce_320 = happyReduce 4# 82# happyReduction_320 +happyReduction_320 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut88 happy_x_2 of { happy_var_2 -> + case happyOut85 happy_x_4 of { happy_var_4 -> + happyIn89 + (happy_var_4 happy_var_2 + ) `HappyStk` happyRest}} + +happyReduce_321 = happyReduce 4# 82# happyReduction_321 +happyReduction_321 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut88 happy_x_3 of { happy_var_3 -> + happyIn89 + (appendDeclrAttrs happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_322 = happyReduce 4# 82# happyReduction_322 +happyReduction_322 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut89 happy_x_3 of { happy_var_3 -> + happyIn89 + (appendDeclrAttrs happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_323 = happyReduce 4# 82# happyReduction_323 +happyReduction_323 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut85 happy_x_3 of { happy_var_3 -> + happyIn89 + (appendDeclrAttrs happy_var_2 (happy_var_3 emptyDeclr) + ) `HappyStk` happyRest}} + +happyReduce_324 = happyReduce 5# 82# happyReduction_324 +happyReduction_324 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut127 happy_x_2 of { happy_var_2 -> + case happyOut88 happy_x_3 of { happy_var_3 -> + case happyOut85 happy_x_5 of { happy_var_5 -> + happyIn89 + (appendDeclrAttrs happy_var_2 (happy_var_5 happy_var_3) + ) `HappyStk` happyRest}}} + +happyReduce_325 = happySpecReduce_2 82# happyReduction_325 +happyReduction_325 happy_x_2 + happy_x_1 + = case happyOut89 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn89 + (appendDeclrAttrs happy_var_2 happy_var_1 + )}} + +happyReduce_326 = happyMonadReduce 1# 83# happyReduction_326 +happyReduction_326 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut115 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CInitExpr happy_var_1)} + ) (\r -> happyReturn (happyIn90 r)) + +happyReduce_327 = happyMonadReduce 3# 83# happyReduction_327 +happyReduction_327 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut92 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CInitList (reverse happy_var_2))}} + ) (\r -> happyReturn (happyIn90 r)) + +happyReduce_328 = happyMonadReduce 4# 83# happyReduction_328 +happyReduction_328 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut92 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CInitList (reverse happy_var_2))}} + ) (\r -> happyReturn (happyIn90 r)) + +happyReduce_329 = happySpecReduce_0 84# happyReduction_329 +happyReduction_329 = happyIn91 + (Nothing + ) + +happyReduce_330 = happySpecReduce_2 84# happyReduction_330 +happyReduction_330 happy_x_2 + happy_x_1 + = case happyOut90 happy_x_2 of { happy_var_2 -> + happyIn91 + (Just happy_var_2 + )} + +happyReduce_331 = happySpecReduce_0 85# happyReduction_331 +happyReduction_331 = happyIn92 + (empty + ) + +happyReduce_332 = happySpecReduce_1 85# happyReduction_332 +happyReduction_332 happy_x_1 + = case happyOut90 happy_x_1 of { happy_var_1 -> + happyIn92 + (singleton ([],happy_var_1) + )} + +happyReduce_333 = happySpecReduce_2 85# happyReduction_333 +happyReduction_333 happy_x_2 + happy_x_1 + = case happyOut93 happy_x_1 of { happy_var_1 -> + case happyOut90 happy_x_2 of { happy_var_2 -> + happyIn92 + (singleton (happy_var_1,happy_var_2) + )}} + +happyReduce_334 = happySpecReduce_3 85# happyReduction_334 +happyReduction_334 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut92 happy_x_1 of { happy_var_1 -> + case happyOut90 happy_x_3 of { happy_var_3 -> + happyIn92 + (happy_var_1 `snoc` ([],happy_var_3) + )}} + +happyReduce_335 = happyReduce 4# 85# happyReduction_335 +happyReduction_335 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut92 happy_x_1 of { happy_var_1 -> + case happyOut93 happy_x_3 of { happy_var_3 -> + case happyOut90 happy_x_4 of { happy_var_4 -> + happyIn92 + (happy_var_1 `snoc` (happy_var_3,happy_var_4) + ) `HappyStk` happyRest}}} + +happyReduce_336 = happySpecReduce_2 86# happyReduction_336 +happyReduction_336 happy_x_2 + happy_x_1 + = case happyOut94 happy_x_1 of { happy_var_1 -> + happyIn93 + (reverse happy_var_1 + )} + +happyReduce_337 = happyMonadReduce 2# 86# happyReduction_337 +happyReduction_337 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut125 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ \at -> [CMemberDesig happy_var_1 at])} + ) (\r -> happyReturn (happyIn93 r)) + +happyReduce_338 = happySpecReduce_1 86# happyReduction_338 +happyReduction_338 happy_x_1 + = case happyOut96 happy_x_1 of { happy_var_1 -> + happyIn93 + ([happy_var_1] + )} + +happyReduce_339 = happySpecReduce_1 87# happyReduction_339 +happyReduction_339 happy_x_1 + = case happyOut95 happy_x_1 of { happy_var_1 -> + happyIn94 + (singleton happy_var_1 + )} + +happyReduce_340 = happySpecReduce_2 87# happyReduction_340 +happyReduction_340 happy_x_2 + happy_x_1 + = case happyOut94 happy_x_1 of { happy_var_1 -> + case happyOut95 happy_x_2 of { happy_var_2 -> + happyIn94 + (happy_var_1 `snoc` happy_var_2 + )}} + +happyReduce_341 = happyMonadReduce 3# 88# happyReduction_341 +happyReduction_341 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut121 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CArrDesig happy_var_2)}} + ) (\r -> happyReturn (happyIn95 r)) + +happyReduce_342 = happyMonadReduce 2# 88# happyReduction_342 +happyReduction_342 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CMemberDesig happy_var_2)}} + ) (\r -> happyReturn (happyIn95 r)) + +happyReduce_343 = happySpecReduce_1 88# happyReduction_343 +happyReduction_343 happy_x_1 + = case happyOut96 happy_x_1 of { happy_var_1 -> + happyIn95 + (happy_var_1 + )} + +happyReduce_344 = happyMonadReduce 5# 89# happyReduction_344 +happyReduction_344 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut121 happy_x_2 of { happy_var_2 -> + case happyOut121 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CRangeDesig happy_var_2 happy_var_4)}}} + ) (\r -> happyReturn (happyIn96 r)) + +happyReduce_345 = happyMonadReduce 1# 90# happyReduction_345 +happyReduction_345 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokIdent _ happy_var_1) -> + ( withNodeInfo happy_var_1 $ CVar happy_var_1)} + ) (\r -> happyReturn (happyIn97 r)) + +happyReduce_346 = happySpecReduce_1 90# happyReduction_346 +happyReduction_346 happy_x_1 + = case happyOut122 happy_x_1 of { happy_var_1 -> + happyIn97 + (CConst happy_var_1 + )} + +happyReduce_347 = happySpecReduce_1 90# happyReduction_347 +happyReduction_347 happy_x_1 + = case happyOut123 happy_x_1 of { happy_var_1 -> + happyIn97 + (CConst (liftStrLit happy_var_1) + )} + +happyReduce_348 = happySpecReduce_3 90# happyReduction_348 +happyReduction_348 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut117 happy_x_2 of { happy_var_2 -> + happyIn97 + (happy_var_2 + )} + +happyReduce_349 = happyMonadReduce 3# 90# happyReduction_349 +happyReduction_349 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CStatExpr happy_var_2)}} + ) (\r -> happyReturn (happyIn97 r)) + +happyReduce_350 = happyMonadReduce 6# 90# happyReduction_350 +happyReduction_350 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut115 happy_x_3 of { happy_var_3 -> + case happyOut83 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CBuiltinExpr . CBuiltinVaArg happy_var_3 happy_var_5)}}} + ) (\r -> happyReturn (happyIn97 r)) + +happyReduce_351 = happyMonadReduce 6# 90# happyReduction_351 +happyReduction_351 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_3 of { happy_var_3 -> + case happyOut98 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CBuiltinExpr . CBuiltinOffsetOf happy_var_3 (reverse happy_var_5))}}} + ) (\r -> happyReturn (happyIn97 r)) + +happyReduce_352 = happyMonadReduce 6# 90# happyReduction_352 +happyReduction_352 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_3 of { happy_var_3 -> + case happyOut83 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CBuiltinExpr . CBuiltinTypesCompatible happy_var_3 happy_var_5)}}} + ) (\r -> happyReturn (happyIn97 r)) + +happyReduce_353 = happyMonadReduce 1# 91# happyReduction_353 +happyReduction_353 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut125 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ singleton . CMemberDesig happy_var_1)} + ) (\r -> happyReturn (happyIn98 r)) + +happyReduce_354 = happyMonadReduce 3# 91# happyReduction_354 +happyReduction_354 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut98 happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_3 $ (happy_var_1 `snoc`) . CMemberDesig happy_var_3)}} + ) (\r -> happyReturn (happyIn98 r)) + +happyReduce_355 = happyMonadReduce 4# 91# happyReduction_355 +happyReduction_355 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut98 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_3 $ (happy_var_1 `snoc`) . CArrDesig happy_var_3)}} + ) (\r -> happyReturn (happyIn98 r)) + +happyReduce_356 = happySpecReduce_1 92# happyReduction_356 +happyReduction_356 happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn99 + (happy_var_1 + )} + +happyReduce_357 = happyMonadReduce 4# 92# happyReduction_357 +happyReduction_357 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut99 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CIndex happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_358 = happyMonadReduce 3# 92# happyReduction_358 +happyReduction_358 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut99 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CCall happy_var_1 [])} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_359 = happyMonadReduce 4# 92# happyReduction_359 +happyReduction_359 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut99 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CCall happy_var_1 (reverse happy_var_3))}} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_360 = happyMonadReduce 3# 92# happyReduction_360 +happyReduction_360 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut99 happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CMember happy_var_1 happy_var_3 False)}} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_361 = happyMonadReduce 3# 92# happyReduction_361 +happyReduction_361 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut99 happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CMember happy_var_1 happy_var_3 True)}} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_362 = happyMonadReduce 2# 92# happyReduction_362 +happyReduction_362 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut99 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CUnary CPostIncOp happy_var_1)} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_363 = happyMonadReduce 2# 92# happyReduction_363 +happyReduction_363 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut99 happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ CUnary CPostDecOp happy_var_1)} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_364 = happyMonadReduce 6# 92# happyReduction_364 +happyReduction_364 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_2 of { happy_var_2 -> + case happyOut92 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CCompoundLit happy_var_2 (reverse happy_var_5))}}} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_365 = happyMonadReduce 7# 92# happyReduction_365 +happyReduction_365 (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) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_2 of { happy_var_2 -> + case happyOut92 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CCompoundLit happy_var_2 (reverse happy_var_5))}}} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_366 = happySpecReduce_1 93# happyReduction_366 +happyReduction_366 happy_x_1 + = case happyOut115 happy_x_1 of { happy_var_1 -> + happyIn100 + (singleton happy_var_1 + )} + +happyReduce_367 = happySpecReduce_3 93# happyReduction_367 +happyReduction_367 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut115 happy_x_3 of { happy_var_3 -> + happyIn100 + (happy_var_1 `snoc` happy_var_3 + )}} + +happyReduce_368 = happySpecReduce_1 94# happyReduction_368 +happyReduction_368 happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn101 + (happy_var_1 + )} + +happyReduce_369 = happyMonadReduce 2# 94# happyReduction_369 +happyReduction_369 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut101 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CUnary CPreIncOp happy_var_2)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_370 = happyMonadReduce 2# 94# happyReduction_370 +happyReduction_370 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut101 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CUnary CPreDecOp happy_var_2)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_371 = happySpecReduce_2 94# happyReduction_371 +happyReduction_371 happy_x_2 + happy_x_1 + = case happyOut103 happy_x_2 of { happy_var_2 -> + happyIn101 + (happy_var_2 + )} + +happyReduce_372 = happyMonadReduce 2# 94# happyReduction_372 +happyReduction_372 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut102 happy_x_1 of { happy_var_1 -> + case happyOut103 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CUnary (unL happy_var_1) happy_var_2)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_373 = happyMonadReduce 2# 94# happyReduction_373 +happyReduction_373 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut101 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CSizeofExpr happy_var_2)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_374 = happyMonadReduce 4# 94# happyReduction_374 +happyReduction_374 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CSizeofType happy_var_3)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_375 = happyMonadReduce 2# 94# happyReduction_375 +happyReduction_375 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut101 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CAlignofExpr happy_var_2)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_376 = happyMonadReduce 4# 94# happyReduction_376 +happyReduction_376 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CAlignofType happy_var_3)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_377 = happyMonadReduce 2# 94# happyReduction_377 +happyReduction_377 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut101 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CComplexReal happy_var_2)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_378 = happyMonadReduce 2# 94# happyReduction_378 +happyReduction_378 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut101 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CComplexImag happy_var_2)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_379 = happyMonadReduce 2# 94# happyReduction_379 +happyReduction_379 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ CLabAddrExpr happy_var_2)}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_380 = happySpecReduce_1 95# happyReduction_380 +happyReduction_380 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102 + (L CAdrOp (posOf happy_var_1) + )} + +happyReduce_381 = happySpecReduce_1 95# happyReduction_381 +happyReduction_381 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102 + (L CIndOp (posOf happy_var_1) + )} + +happyReduce_382 = happySpecReduce_1 95# happyReduction_382 +happyReduction_382 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102 + (L CPlusOp (posOf happy_var_1) + )} + +happyReduce_383 = happySpecReduce_1 95# happyReduction_383 +happyReduction_383 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102 + (L CMinOp (posOf happy_var_1) + )} + +happyReduce_384 = happySpecReduce_1 95# happyReduction_384 +happyReduction_384 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102 + (L CCompOp (posOf happy_var_1) + )} + +happyReduce_385 = happySpecReduce_1 95# happyReduction_385 +happyReduction_385 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102 + (L CNegOp (posOf happy_var_1) + )} + +happyReduce_386 = happySpecReduce_1 96# happyReduction_386 +happyReduction_386 happy_x_1 + = case happyOut101 happy_x_1 of { happy_var_1 -> + happyIn103 + (happy_var_1 + )} + +happyReduce_387 = happyMonadReduce 4# 96# happyReduction_387 +happyReduction_387 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_2 of { happy_var_2 -> + case happyOut103 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CCast happy_var_2 happy_var_4)}}} + ) (\r -> happyReturn (happyIn103 r)) + +happyReduce_388 = happySpecReduce_1 97# happyReduction_388 +happyReduction_388 happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + happyIn104 + (happy_var_1 + )} + +happyReduce_389 = happyMonadReduce 3# 97# happyReduction_389 +happyReduction_389 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut104 happy_x_1 of { happy_var_1 -> + case happyOut103 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CMulOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn104 r)) + +happyReduce_390 = happyMonadReduce 3# 97# happyReduction_390 +happyReduction_390 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut104 happy_x_1 of { happy_var_1 -> + case happyOut103 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CDivOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn104 r)) + +happyReduce_391 = happyMonadReduce 3# 97# happyReduction_391 +happyReduction_391 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut104 happy_x_1 of { happy_var_1 -> + case happyOut103 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CRmdOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn104 r)) + +happyReduce_392 = happySpecReduce_1 98# happyReduction_392 +happyReduction_392 happy_x_1 + = case happyOut104 happy_x_1 of { happy_var_1 -> + happyIn105 + (happy_var_1 + )} + +happyReduce_393 = happyMonadReduce 3# 98# happyReduction_393 +happyReduction_393 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut105 happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CAddOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn105 r)) + +happyReduce_394 = happyMonadReduce 3# 98# happyReduction_394 +happyReduction_394 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut105 happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CSubOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn105 r)) + +happyReduce_395 = happySpecReduce_1 99# happyReduction_395 +happyReduction_395 happy_x_1 + = case happyOut105 happy_x_1 of { happy_var_1 -> + happyIn106 + (happy_var_1 + )} + +happyReduce_396 = happyMonadReduce 3# 99# happyReduction_396 +happyReduction_396 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut106 happy_x_1 of { happy_var_1 -> + case happyOut105 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CShlOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn106 r)) + +happyReduce_397 = happyMonadReduce 3# 99# happyReduction_397 +happyReduction_397 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut106 happy_x_1 of { happy_var_1 -> + case happyOut105 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CShrOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn106 r)) + +happyReduce_398 = happySpecReduce_1 100# happyReduction_398 +happyReduction_398 happy_x_1 + = case happyOut106 happy_x_1 of { happy_var_1 -> + happyIn107 + (happy_var_1 + )} + +happyReduce_399 = happyMonadReduce 3# 100# happyReduction_399 +happyReduction_399 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut107 happy_x_1 of { happy_var_1 -> + case happyOut106 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CLeOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn107 r)) + +happyReduce_400 = happyMonadReduce 3# 100# happyReduction_400 +happyReduction_400 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut107 happy_x_1 of { happy_var_1 -> + case happyOut106 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CGrOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn107 r)) + +happyReduce_401 = happyMonadReduce 3# 100# happyReduction_401 +happyReduction_401 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut107 happy_x_1 of { happy_var_1 -> + case happyOut106 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CLeqOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn107 r)) + +happyReduce_402 = happyMonadReduce 3# 100# happyReduction_402 +happyReduction_402 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut107 happy_x_1 of { happy_var_1 -> + case happyOut106 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CGeqOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn107 r)) + +happyReduce_403 = happySpecReduce_1 101# happyReduction_403 +happyReduction_403 happy_x_1 + = case happyOut107 happy_x_1 of { happy_var_1 -> + happyIn108 + (happy_var_1 + )} + +happyReduce_404 = happyMonadReduce 3# 101# happyReduction_404 +happyReduction_404 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut108 happy_x_1 of { happy_var_1 -> + case happyOut107 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CEqOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn108 r)) + +happyReduce_405 = happyMonadReduce 3# 101# happyReduction_405 +happyReduction_405 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut108 happy_x_1 of { happy_var_1 -> + case happyOut107 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CNeqOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn108 r)) + +happyReduce_406 = happySpecReduce_1 102# happyReduction_406 +happyReduction_406 happy_x_1 + = case happyOut108 happy_x_1 of { happy_var_1 -> + happyIn109 + (happy_var_1 + )} + +happyReduce_407 = happyMonadReduce 3# 102# happyReduction_407 +happyReduction_407 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut109 happy_x_1 of { happy_var_1 -> + case happyOut108 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CAndOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn109 r)) + +happyReduce_408 = happySpecReduce_1 103# happyReduction_408 +happyReduction_408 happy_x_1 + = case happyOut109 happy_x_1 of { happy_var_1 -> + happyIn110 + (happy_var_1 + )} + +happyReduce_409 = happyMonadReduce 3# 103# happyReduction_409 +happyReduction_409 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut110 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CXorOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn110 r)) + +happyReduce_410 = happySpecReduce_1 104# happyReduction_410 +happyReduction_410 happy_x_1 + = case happyOut110 happy_x_1 of { happy_var_1 -> + happyIn111 + (happy_var_1 + )} + +happyReduce_411 = happyMonadReduce 3# 104# happyReduction_411 +happyReduction_411 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut111 happy_x_1 of { happy_var_1 -> + case happyOut110 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary COrOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn111 r)) + +happyReduce_412 = happySpecReduce_1 105# happyReduction_412 +happyReduction_412 happy_x_1 + = case happyOut111 happy_x_1 of { happy_var_1 -> + happyIn112 + (happy_var_1 + )} + +happyReduce_413 = happyMonadReduce 3# 105# happyReduction_413 +happyReduction_413 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut112 happy_x_1 of { happy_var_1 -> + case happyOut111 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CLndOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn112 r)) + +happyReduce_414 = happySpecReduce_1 106# happyReduction_414 +happyReduction_414 happy_x_1 + = case happyOut112 happy_x_1 of { happy_var_1 -> + happyIn113 + (happy_var_1 + )} + +happyReduce_415 = happyMonadReduce 3# 106# happyReduction_415 +happyReduction_415 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut113 happy_x_1 of { happy_var_1 -> + case happyOut112 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CBinary CLorOp happy_var_1 happy_var_3)}} + ) (\r -> happyReturn (happyIn113 r)) + +happyReduce_416 = happySpecReduce_1 107# happyReduction_416 +happyReduction_416 happy_x_1 + = case happyOut113 happy_x_1 of { happy_var_1 -> + happyIn114 + (happy_var_1 + )} + +happyReduce_417 = happyMonadReduce 5# 107# happyReduction_417 +happyReduction_417 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut113 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + case happyOut114 happy_x_5 of { happy_var_5 -> + ( withNodeInfo happy_var_1 $ CCond happy_var_1 (Just happy_var_3) happy_var_5)}}} + ) (\r -> happyReturn (happyIn114 r)) + +happyReduce_418 = happyMonadReduce 4# 107# happyReduction_418 +happyReduction_418 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut113 happy_x_1 of { happy_var_1 -> + case happyOut114 happy_x_4 of { happy_var_4 -> + ( withNodeInfo happy_var_1 $ CCond happy_var_1 Nothing happy_var_4)}} + ) (\r -> happyReturn (happyIn114 r)) + +happyReduce_419 = happySpecReduce_1 108# happyReduction_419 +happyReduction_419 happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn115 + (happy_var_1 + )} + +happyReduce_420 = happyMonadReduce 3# 108# happyReduction_420 +happyReduction_420 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut101 happy_x_1 of { happy_var_1 -> + case happyOut116 happy_x_2 of { happy_var_2 -> + case happyOut115 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ CAssign (unL happy_var_2) happy_var_1 happy_var_3)}}} + ) (\r -> happyReturn (happyIn115 r)) + +happyReduce_421 = happySpecReduce_1 109# happyReduction_421 +happyReduction_421 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CAssignOp (posOf happy_var_1) + )} + +happyReduce_422 = happySpecReduce_1 109# happyReduction_422 +happyReduction_422 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CMulAssOp (posOf happy_var_1) + )} + +happyReduce_423 = happySpecReduce_1 109# happyReduction_423 +happyReduction_423 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CDivAssOp (posOf happy_var_1) + )} + +happyReduce_424 = happySpecReduce_1 109# happyReduction_424 +happyReduction_424 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CRmdAssOp (posOf happy_var_1) + )} + +happyReduce_425 = happySpecReduce_1 109# happyReduction_425 +happyReduction_425 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CAddAssOp (posOf happy_var_1) + )} + +happyReduce_426 = happySpecReduce_1 109# happyReduction_426 +happyReduction_426 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CSubAssOp (posOf happy_var_1) + )} + +happyReduce_427 = happySpecReduce_1 109# happyReduction_427 +happyReduction_427 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CShlAssOp (posOf happy_var_1) + )} + +happyReduce_428 = happySpecReduce_1 109# happyReduction_428 +happyReduction_428 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CShrAssOp (posOf happy_var_1) + )} + +happyReduce_429 = happySpecReduce_1 109# happyReduction_429 +happyReduction_429 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CAndAssOp (posOf happy_var_1) + )} + +happyReduce_430 = happySpecReduce_1 109# happyReduction_430 +happyReduction_430 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L CXorAssOp (posOf happy_var_1) + )} + +happyReduce_431 = happySpecReduce_1 109# happyReduction_431 +happyReduction_431 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn116 + (L COrAssOp (posOf happy_var_1) + )} + +happyReduce_432 = happySpecReduce_1 110# happyReduction_432 +happyReduction_432 happy_x_1 + = case happyOut115 happy_x_1 of { happy_var_1 -> + happyIn117 + (happy_var_1 + )} + +happyReduce_433 = happyMonadReduce 3# 110# happyReduction_433 +happyReduction_433 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut115 happy_x_1 of { happy_var_1 -> + case happyOut118 happy_x_3 of { happy_var_3 -> + ( let es = reverse happy_var_3 in withNodeInfo es $ CComma (happy_var_1:es))}} + ) (\r -> happyReturn (happyIn117 r)) + +happyReduce_434 = happySpecReduce_1 111# happyReduction_434 +happyReduction_434 happy_x_1 + = case happyOut115 happy_x_1 of { happy_var_1 -> + happyIn118 + (singleton happy_var_1 + )} + +happyReduce_435 = happySpecReduce_3 111# happyReduction_435 +happyReduction_435 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut118 happy_x_1 of { happy_var_1 -> + case happyOut115 happy_x_3 of { happy_var_3 -> + happyIn118 + (happy_var_1 `snoc` happy_var_3 + )}} + +happyReduce_436 = happySpecReduce_0 112# happyReduction_436 +happyReduction_436 = happyIn119 + (Nothing + ) + +happyReduce_437 = happySpecReduce_1 112# happyReduction_437 +happyReduction_437 happy_x_1 + = case happyOut117 happy_x_1 of { happy_var_1 -> + happyIn119 + (Just happy_var_1 + )} + +happyReduce_438 = happySpecReduce_0 113# happyReduction_438 +happyReduction_438 = happyIn120 + (Nothing + ) + +happyReduce_439 = happySpecReduce_1 113# happyReduction_439 +happyReduction_439 happy_x_1 + = case happyOut115 happy_x_1 of { happy_var_1 -> + happyIn120 + (Just happy_var_1 + )} + +happyReduce_440 = happySpecReduce_1 114# happyReduction_440 +happyReduction_440 happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn121 + (happy_var_1 + )} + +happyReduce_441 = happyMonadReduce 1# 115# happyReduction_441 +happyReduction_441 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ case happy_var_1 of CTokILit _ i -> CIntConst i)} + ) (\r -> happyReturn (happyIn122 r)) + +happyReduce_442 = happyMonadReduce 1# 115# happyReduction_442 +happyReduction_442 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ case happy_var_1 of CTokCLit _ c -> CCharConst c)} + ) (\r -> happyReturn (happyIn122 r)) + +happyReduce_443 = happyMonadReduce 1# 115# happyReduction_443 +happyReduction_443 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ case happy_var_1 of CTokFLit _ f -> CFloatConst f)} + ) (\r -> happyReturn (happyIn122 r)) + +happyReduce_444 = happyMonadReduce 1# 116# happyReduction_444 +happyReduction_444 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ case happy_var_1 of CTokSLit _ s -> CStrLit s)} + ) (\r -> happyReturn (happyIn123 r)) + +happyReduce_445 = happyMonadReduce 2# 116# happyReduction_445 +happyReduction_445 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut124 happy_x_2 of { happy_var_2 -> + ( withNodeInfo happy_var_1 $ case happy_var_1 of CTokSLit _ s -> CStrLit (concatCStrings (s : reverse happy_var_2)))}} + ) (\r -> happyReturn (happyIn123 r)) + +happyReduce_446 = happySpecReduce_1 117# happyReduction_446 +happyReduction_446 happy_x_1 + = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn124 + (case happy_var_1 of CTokSLit _ s -> singleton s + )} + +happyReduce_447 = happySpecReduce_2 117# happyReduction_447 +happyReduction_447 happy_x_2 + happy_x_1 + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn124 + (case happy_var_2 of CTokSLit _ s -> happy_var_1 `snoc` s + )}} + +happyReduce_448 = happySpecReduce_1 118# happyReduction_448 +happyReduction_448 happy_x_1 + = case happyOutTok happy_x_1 of { (CTokIdent _ happy_var_1) -> + happyIn125 + (happy_var_1 + )} + +happyReduce_449 = happySpecReduce_1 118# happyReduction_449 +happyReduction_449 happy_x_1 + = case happyOutTok happy_x_1 of { (CTokTyIdent _ happy_var_1) -> + happyIn125 + (happy_var_1 + )} + +happyReduce_450 = happySpecReduce_0 119# happyReduction_450 +happyReduction_450 = happyIn126 + ([] + ) + +happyReduce_451 = happySpecReduce_1 119# happyReduction_451 +happyReduction_451 happy_x_1 + = case happyOut127 happy_x_1 of { happy_var_1 -> + happyIn126 + (happy_var_1 + )} + +happyReduce_452 = happySpecReduce_1 120# happyReduction_452 +happyReduction_452 happy_x_1 + = case happyOut128 happy_x_1 of { happy_var_1 -> + happyIn127 + (happy_var_1 + )} + +happyReduce_453 = happySpecReduce_2 120# happyReduction_453 +happyReduction_453 happy_x_2 + happy_x_1 + = case happyOut127 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn127 + (happy_var_1 ++ happy_var_2 + )}} + +happyReduce_454 = happyReduce 6# 121# happyReduction_454 +happyReduction_454 (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 happyOut129 happy_x_4 of { happy_var_4 -> + happyIn128 + (reverse happy_var_4 + ) `HappyStk` happyRest} + +happyReduce_455 = happySpecReduce_1 122# happyReduction_455 +happyReduction_455 happy_x_1 + = case happyOut130 happy_x_1 of { happy_var_1 -> + happyIn129 + (case happy_var_1 of Nothing -> empty; Just attr -> singleton attr + )} + +happyReduce_456 = happySpecReduce_3 122# happyReduction_456 +happyReduction_456 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut129 happy_x_1 of { happy_var_1 -> + case happyOut130 happy_x_3 of { happy_var_3 -> + happyIn129 + ((maybe id (flip snoc) happy_var_3) happy_var_1 + )}} + +happyReduce_457 = happySpecReduce_0 123# happyReduction_457 +happyReduction_457 = happyIn130 + (Nothing + ) + +happyReduce_458 = happyMonadReduce 1# 123# happyReduction_458 +happyReduction_458 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokIdent _ happy_var_1) -> + ( withNodeInfo happy_var_1 $ Just . CAttr happy_var_1 [])} + ) (\r -> happyReturn (happyIn130 r)) + +happyReduce_459 = happyMonadReduce 1# 123# happyReduction_459 +happyReduction_459 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( withNodeInfo happy_var_1 $ Just . CAttr (internalIdent "const") [])} + ) (\r -> happyReturn (happyIn130 r)) + +happyReduce_460 = happyMonadReduce 4# 123# happyReduction_460 +happyReduction_460 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokIdent _ happy_var_1) -> + case happyOut131 happy_x_3 of { happy_var_3 -> + ( withNodeInfo happy_var_1 $ Just . CAttr happy_var_1 (reverse happy_var_3))}} + ) (\r -> happyReturn (happyIn130 r)) + +happyReduce_461 = happyMonadReduce 3# 123# happyReduction_461 +happyReduction_461 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (CTokIdent _ happy_var_1) -> + ( withNodeInfo happy_var_1 $ Just . CAttr happy_var_1 [])} + ) (\r -> happyReturn (happyIn130 r)) + +happyReduce_462 = happySpecReduce_1 124# happyReduction_462 +happyReduction_462 happy_x_1 + = case happyOut121 happy_x_1 of { happy_var_1 -> + happyIn131 + (singleton happy_var_1 + )} + +happyReduce_463 = happySpecReduce_3 124# happyReduction_463 +happyReduction_463 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut131 happy_x_1 of { happy_var_1 -> + case happyOut121 happy_x_3 of { happy_var_3 -> + happyIn131 + (happy_var_1 `snoc` happy_var_3 + )}} + +happyNewToken action sts stk + = lexC(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + CTokEof -> happyDoAction 101# tk action sts stk; + CTokLParen _ -> cont 1#; + CTokRParen _ -> cont 2#; + CTokLBracket _ -> cont 3#; + CTokRBracket _ -> cont 4#; + CTokArrow _ -> cont 5#; + CTokDot _ -> cont 6#; + CTokExclam _ -> cont 7#; + CTokTilde _ -> cont 8#; + CTokInc _ -> cont 9#; + CTokDec _ -> cont 10#; + CTokPlus _ -> cont 11#; + CTokMinus _ -> cont 12#; + CTokStar _ -> cont 13#; + CTokSlash _ -> cont 14#; + CTokPercent _ -> cont 15#; + CTokAmper _ -> cont 16#; + CTokShiftL _ -> cont 17#; + CTokShiftR _ -> cont 18#; + CTokLess _ -> cont 19#; + CTokLessEq _ -> cont 20#; + CTokHigh _ -> cont 21#; + CTokHighEq _ -> cont 22#; + CTokEqual _ -> cont 23#; + CTokUnequal _ -> cont 24#; + CTokHat _ -> cont 25#; + CTokBar _ -> cont 26#; + CTokAnd _ -> cont 27#; + CTokOr _ -> cont 28#; + CTokQuest _ -> cont 29#; + CTokColon _ -> cont 30#; + CTokAssign _ -> cont 31#; + CTokPlusAss _ -> cont 32#; + CTokMinusAss _ -> cont 33#; + CTokStarAss _ -> cont 34#; + CTokSlashAss _ -> cont 35#; + CTokPercAss _ -> cont 36#; + CTokAmpAss _ -> cont 37#; + CTokHatAss _ -> cont 38#; + CTokBarAss _ -> cont 39#; + CTokSLAss _ -> cont 40#; + CTokSRAss _ -> cont 41#; + CTokComma _ -> cont 42#; + CTokSemic _ -> cont 43#; + CTokLBrace _ -> cont 44#; + CTokRBrace _ -> cont 45#; + CTokEllipsis _ -> cont 46#; + CTokAlignof _ -> cont 47#; + CTokAsm _ -> cont 48#; + CTokAuto _ -> cont 49#; + CTokBreak _ -> cont 50#; + CTokBool _ -> cont 51#; + CTokCase _ -> cont 52#; + CTokChar _ -> cont 53#; + CTokConst _ -> cont 54#; + CTokContinue _ -> cont 55#; + CTokComplex _ -> cont 56#; + CTokDefault _ -> cont 57#; + CTokDo _ -> cont 58#; + CTokDouble _ -> cont 59#; + CTokElse _ -> cont 60#; + CTokEnum _ -> cont 61#; + CTokExtern _ -> cont 62#; + CTokFloat _ -> cont 63#; + CTokFor _ -> cont 64#; + CTokGoto _ -> cont 65#; + CTokIf _ -> cont 66#; + CTokInline _ -> cont 67#; + CTokInt _ -> cont 68#; + CTokLong _ -> cont 69#; + CTokLabel _ -> cont 70#; + CTokRegister _ -> cont 71#; + CTokRestrict _ -> cont 72#; + CTokReturn _ -> cont 73#; + CTokShort _ -> cont 74#; + CTokSigned _ -> cont 75#; + CTokSizeof _ -> cont 76#; + CTokStatic _ -> cont 77#; + CTokStruct _ -> cont 78#; + CTokSwitch _ -> cont 79#; + CTokTypedef _ -> cont 80#; + CTokTypeof _ -> cont 81#; + CTokThread _ -> cont 82#; + CTokUnion _ -> cont 83#; + CTokUnsigned _ -> cont 84#; + CTokVoid _ -> cont 85#; + CTokVolatile _ -> cont 86#; + CTokWhile _ -> cont 87#; + CTokCLit _ _ -> cont 88#; + CTokILit _ _ -> cont 89#; + CTokFLit _ _ -> cont 90#; + CTokSLit _ _ -> cont 91#; + CTokIdent _ happy_dollar_dollar -> cont 92#; + CTokTyIdent _ happy_dollar_dollar -> cont 93#; + CTokGnuC GnuCAttrTok _ -> cont 94#; + CTokGnuC GnuCExtTok _ -> cont 95#; + CTokGnuC GnuCComplexReal _ -> cont 96#; + CTokGnuC GnuCComplexImag _ -> cont 97#; + CTokGnuC GnuCVaArg _ -> cont 98#; + CTokGnuC GnuCOffsetof _ -> cont 99#; + CTokGnuC GnuCTyCompat _ -> cont 100#; + _ -> happyError' tk + }) + +happyError_ tk = happyError' tk + +happyThen :: () => P a -> (a -> P b) -> P b +happyThen = (>>=) +happyReturn :: () => a -> P a +happyReturn = (return) +happyThen1 = happyThen +happyReturn1 :: () => a -> P a +happyReturn1 = happyReturn +happyError' :: () => CToken -> P a +happyError' tk = (\token -> happyError) tk + +translation_unit = happySomeParser where + happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut7 x)) + +external_declaration = happySomeParser where + happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut9 x)) + +statement = happySomeParser where + happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut12 x)) + +expression = happySomeParser where + happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut117 x)) + +happySeq = happyDontSeq + + +-- sometimes it is neccessary to reverse an unreversed list +reverseList :: [a] -> Reversed [a] +reverseList = Reversed . List.reverse + +-- We occasionally need things to have a location when they don't naturally +-- have one built in as tokens and most AST elements do. +-- +data Located a = L !a !Position + +unL :: Located a -> a +unL (L a pos) = a + +instance Pos (Located a) where + posOf (L _ pos) = pos + +-- FIXME: the next 3 inlines here increase the object file size by 70% +-- Check whether the speed win is worth it +{-# INLINE withNodeInfo #-} +withNodeInfo :: Pos node => node -> (NodeInfo -> a) -> P a +withNodeInfo node mkAttrNode = do + name <- getNewName + lastTok <- getSavedToken + let firstPos = posOf node + let attrs = mkNodeInfo' firstPos (posLenOfTok $! lastTok) name + attrs `seq` return (mkAttrNode attrs) + +{-# INLINE withLength #-} +withLength :: NodeInfo -> (NodeInfo -> a) -> P a +withLength nodeinfo mkAttrNode = do + lastTok <- getSavedToken + let firstPos = posOfNode nodeinfo + let attrs = mkNodeInfo' firstPos (posLenOfTok $! lastTok) + (maybe (error "nameOfNode") id (nameOfNode nodeinfo)) + attrs `seq` return (mkAttrNode attrs) + +data CDeclrR = CDeclrR (Maybe Ident) (Reversed [CDerivedDeclr]) (Maybe CStrLit) [CAttr] NodeInfo +reverseDeclr :: CDeclrR -> CDeclr +reverseDeclr (CDeclrR ide reversedDDs asmname cattrs at) + = CDeclr ide (reverse reversedDDs) asmname cattrs at +instance CNode (CDeclrR) where + nodeInfo (CDeclrR _ _ _ _ n) = n +instance Pos (CDeclrR) where + posOf (CDeclrR _ _ _ _ n) = posOf n + +{-# INLINE withAttribute #-} +withAttribute :: Pos node => node -> [CAttr] -> (NodeInfo -> CDeclrR) -> P CDeclrR +withAttribute node cattrs mkDeclrNode = do + name <- getNewName + let attrs = mkNodeInfo (posOf node) name + let newDeclr = appendDeclrAttrs cattrs $ mkDeclrNode attrs + attrs `seq` newDeclr `seq` return newDeclr + +-- postfixing variant +{-# INLINE withAttributePF #-} +withAttributePF :: Pos node => node -> [CAttr] -> (NodeInfo -> CDeclrR -> CDeclrR) -> P (CDeclrR -> CDeclrR) +withAttributePF node cattrs mkDeclrCtor = do + name <- getNewName + let attrs = mkNodeInfo (posOf node) name + let newDeclr = appendDeclrAttrs cattrs . mkDeclrCtor attrs + attrs `seq` newDeclr `seq` return newDeclr + +-- add top level attributes for a declarator. +-- +-- In the following example +-- +-- > int declr1, __attribute__((a1)) * __attribute__((a2)) y() __asm__("$" "y") __attribute__((a3)); +-- +-- the attributes `a1' and `a3' are top-level attributes for y. +-- The (pseudo)-AST for the second declarator is +-- +-- > CDeclr "y" +-- > [CFunDeclr ..., CPtrDeclr __attribute__((a2)) ... ] +-- > (asm "$y") +-- > [__attribute__((a1)), __attribute__((a3)) ] +-- +-- So assembler names and preceeding and trailing attributes are recorded in object declarator. +-- +appendObjAttrs :: [CAttr] -> CDeclr -> CDeclr +appendObjAttrs newAttrs (CDeclr ident indirections asmname cAttrs at) + = CDeclr ident indirections asmname (cAttrs ++ newAttrs) at +appendObjAttrsR :: [CAttr] -> CDeclrR -> CDeclrR +appendObjAttrsR newAttrs (CDeclrR ident indirections asmname cAttrs at) + = CDeclrR ident indirections asmname (cAttrs ++ newAttrs) at + +setAsmName :: Maybe CStrLit -> CDeclrR -> P CDeclrR +setAsmName mAsmName (CDeclrR ident indirections oldName cattrs at) = + case combineName mAsmName oldName of + Left (n1,n2) -> failP (posOf n2) ["Duplicate assembler name: ",showName n1,showName n2] + Right newName -> return $ CDeclrR ident indirections newName cattrs at + where + combineName Nothing Nothing = Right Nothing + combineName Nothing oldname@(Just _) = Right oldname + combineName newname@(Just _) Nothing = Right newname + combineName (Just n1) (Just n2) = Left (n1,n2) + showName (CStrLit cstr _) = show cstr + +withAsmNameAttrs :: (Maybe CStrLit, [CAttr]) -> CDeclrR -> P CDeclrR +withAsmNameAttrs (mAsmName, newAttrs) declr = setAsmName mAsmName (appendObjAttrsR newAttrs declr) + +appendDeclrAttrs :: [CAttr] -> CDeclrR -> CDeclrR +appendDeclrAttrs newAttrs (CDeclrR ident (Reversed []) asmname cattrs at) + = CDeclrR ident empty asmname (cattrs ++ newAttrs) at +appendDeclrAttrs newAttrs (CDeclrR ident (Reversed (x:xs)) asmname cattrs at) + = CDeclrR ident (Reversed (appendAttrs x : xs)) asmname cattrs at where + appendAttrs (CPtrDeclr typeQuals at) = CPtrDeclr (typeQuals ++ map CAttrQual newAttrs) at + appendAttrs (CArrDeclr typeQuals arraySize at) = CArrDeclr (typeQuals ++ map CAttrQual newAttrs) arraySize at + appendAttrs (CFunDeclr parameters cattrs at) = CFunDeclr parameters (cattrs ++ newAttrs) at + +ptrDeclr :: CDeclrR -> [CTypeQual] -> NodeInfo -> CDeclrR +ptrDeclr (CDeclrR ident derivedDeclrs asmname cattrs dat) tyquals at + = CDeclrR ident (derivedDeclrs `snoc` CPtrDeclr tyquals at) asmname cattrs dat +funDeclr :: CDeclrR -> (Either [Ident] ([CDecl],Bool)) -> [CAttr] -> NodeInfo -> CDeclrR +funDeclr (CDeclrR ident derivedDeclrs asmname dcattrs dat) params cattrs at + = CDeclrR ident (derivedDeclrs `snoc` CFunDeclr params cattrs at) asmname dcattrs dat +arrDeclr :: CDeclrR -> [CTypeQual] -> Bool -> Bool -> Maybe CExpr -> NodeInfo -> CDeclrR +arrDeclr (CDeclrR ident derivedDeclrs asmname cattrs dat) tyquals var_sized static_size size_expr_opt at + = arr_sz `seq` ( CDeclrR ident (derivedDeclrs `snoc` CArrDeclr tyquals arr_sz at) asmname cattrs dat ) + where + arr_sz = case size_expr_opt of + Just e -> CArrSize static_size e + Nothing -> CNoArrSize var_sized + +liftTypeQuals :: Reversed [CTypeQual] -> [CDeclSpec] +liftTypeQuals = map CTypeQual . reverse + +-- lift CAttrs to DeclSpecs +-- +liftCAttrs :: [CAttr] -> [CDeclSpec] +liftCAttrs = map (CTypeQual . CAttrQual) + +-- when we parsed (decl_spec_1,...,decl_spec_n,attrs), add the __attributes__s to the declspec list +-- needs special care when @decl_spec_n@ is a SUE definition +addTrailingAttrs :: Reversed [CDeclSpec] -> [CAttr] -> Reversed [CDeclSpec] +addTrailingAttrs declspecs new_attrs = + case viewr declspecs of + (specs_init, CTypeSpec (CSUType (CStruct tag name (Just def) def_attrs su_node) node)) + -> (specs_init `snoc` CTypeSpec (CSUType (CStruct tag name (Just def) (def_attrs ++ new_attrs) su_node) node)) + (specs_init, CTypeSpec (CEnumType (CEnum name (Just def) def_attrs e_node) node)) + -> (specs_init `snoc` CTypeSpec (CEnumType (CEnum name (Just def) (def_attrs ++ new_attrs) e_node) node)) + _ -> declspecs `rappend` (liftCAttrs new_attrs) + +-- convenient instance, the position of a list of things is the position of +-- the first thing in the list +-- +instance Pos a => Pos [a] where + posOf (x:_) = posOf x + +instance Pos a => Pos (Reversed a) where + posOf (Reversed x) = posOf x + +emptyDeclr :: CDeclrR +emptyDeclr = CDeclrR Nothing empty Nothing [] undefNode +mkVarDeclr :: Ident -> NodeInfo -> CDeclrR +mkVarDeclr ident = CDeclrR (Just ident) empty Nothing [] + +-- Take the identifiers and use them to update the typedef'ed identifier set +-- if the decl is defining a typedef then we add it to the set, +-- if it's a var decl then that shadows typedefed identifiers +-- +doDeclIdent :: [CDeclSpec] -> CDeclrR -> P () +doDeclIdent declspecs (CDeclrR mIdent _ _ _ _) = + case mIdent of + Nothing -> return () + Just ident | any iypedef declspecs -> addTypedef ident + | otherwise -> shadowTypedef ident + + where iypedef (CStorageSpec (CTypedef _)) = True + iypedef _ = False + +doFuncParamDeclIdent :: CDeclr -> P () +doFuncParamDeclIdent (CDeclr _ (CFunDeclr params _ _ : _) _ _ _) = + sequence_ + [ case getCDeclrIdent declr of + Nothing -> return () + Just ident -> shadowTypedef ident + | CDecl _ dle _ <- either (const []) fst params + , (Just declr, _, _) <- dle ] +doFuncParamDeclIdent _ = return () + +-- extract all identifiers +getCDeclrIdent :: CDeclr -> Maybe Ident +getCDeclrIdent (CDeclr mIdent _ _ _ _) = mIdent + +happyError :: P a +happyError = parseError + +-- * public interface + +-- | @parseC input initialPos@ parses the given preprocessed C-source input and returns the AST or a list of parse errors. +parseC :: InputStream -> Position -> Either ParseError CTranslUnit +parseC input initialPosition = + fmap fst $ execParser translUnitP input initialPosition builtinTypeNames (namesStartingFrom 0) + +-- | @translUnitP@ provides a parser for a complete C translation unit, i.e. a list of external declarations. +translUnitP :: P CTranslUnit +translUnitP = translation_unit +-- | @extDeclP@ provides a parser for an external (file-scope) declaration +extDeclP :: P CExtDecl +extDeclP = external_declaration +-- | @statementP@ provides a parser for C statements +statementP :: P CStat +statementP = statement +-- | @expressionP@ provides a parser for C expressions +expressionP :: P CExpr +expressionP = expression +{-# LINE 1 "GenericTemplate.hs" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "GenericTemplate.hs" #-} +-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp + +{-# LINE 28 "GenericTemplate.hs" #-} + + +data Happy_IntList = HappyCons Int# Happy_IntList + + + + + +{-# LINE 49 "GenericTemplate.hs" #-} + +{-# LINE 59 "GenericTemplate.hs" #-} + +{-# LINE 68 "GenericTemplate.hs" #-} + +infixr 9 `HappyStk` +data HappyStk a = HappyStk a (HappyStk a) + +----------------------------------------------------------------------------- +-- starting the parse + +happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll + +----------------------------------------------------------------------------- +-- Accepting the parse + +-- If the current token is 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 "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 "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. diff --git a/Test/examples/ClassInstType.hs b/Test/examples/ClassInstType.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ClassInstType.hs @@ -0,0 +1,17 @@ +module ClassInstType where + +class Dir d where + localDir :: d -> IO FilePath + +instance Dir Directory where + localDir (Local f) = return f + + localDir (Darcs {url=url,darcsVersion=Patch patch,subDirectory=subDir}) = do + tmp <- createTempDir 0 "haskelld" + darcsOut <- runDarcsCommand tmp "get" ["--lazy","--to-match","hash "++ patch,url,"fs"] + print darcsOut + let (ExitSuccess,"",out) = darcsOut + print out + return $ tmp "fs" subDir + +type URL = String diff --git a/Test/examples/DataHeadParen.hs b/Test/examples/DataHeadParen.hs new file mode 100644 --- /dev/null +++ b/Test/examples/DataHeadParen.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE TypeOperators #-} +module DataHeadParen where + +data (a1 :< a2) = Foo diff --git a/Test/examples/Directory.hs b/Test/examples/Directory.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Directory.hs @@ -0,0 +1,913 @@ +{-# LANGUAGE ForeignFunctionInterface #-} + +----------------------------------------------------------------------------- +-- | +-- Module : System.Directory +-- Copyright : (c) The University of Glasgow 2001 +-- License : BSD-style (see the file libraries/base/LICENSE) +-- +-- Maintainer : libraries@haskell.org +-- Stability : stable +-- Portability : portable +-- +-- System-independent interface to directory manipulation. +-- +----------------------------------------------------------------------------- + +module System.Directory + ( + -- $intro + + -- * Actions on directories + createDirectory -- :: FilePath -> IO () + , createDirectoryIfMissing -- :: Bool -> FilePath -> IO () + , removeDirectory -- :: FilePath -> IO () + , removeDirectoryRecursive -- :: FilePath -> IO () + , renameDirectory -- :: FilePath -> FilePath -> IO () + + , getDirectoryContents -- :: FilePath -> IO [FilePath] + , getCurrentDirectory -- :: IO FilePath + , setCurrentDirectory -- :: FilePath -> IO () + + -- * Pre-defined directories + , getHomeDirectory + , getAppUserDataDirectory + , getUserDocumentsDirectory + , getTemporaryDirectory + + -- * Actions on files + , removeFile -- :: FilePath -> IO () + , renameFile -- :: FilePath -> FilePath -> IO () + , copyFile -- :: FilePath -> FilePath -> IO () + + , canonicalizePath + , makeRelativeToCurrentDirectory + , findExecutable + + -- * Existence tests + , doesFileExist -- :: FilePath -> IO Bool + , doesDirectoryExist -- :: FilePath -> IO Bool + + -- * Permissions + + -- $permissions + + , Permissions( + Permissions, + readable, -- :: Permissions -> Bool + writable, -- :: Permissions -> Bool + executable, -- :: Permissions -> Bool + searchable -- :: Permissions -> Bool + ) + + , getPermissions -- :: FilePath -> IO Permissions + , setPermissions -- :: FilePath -> Permissions -> IO () + , copyPermissions + + -- * Timestamps + + , getModificationTime -- :: FilePath -> IO ClockTime + ) where + +import Prelude hiding ( catch ) +import qualified Prelude + +import Control.Monad (guard) +import System.Environment ( getEnv ) +import System.FilePath +import System.IO +import System.IO.Error hiding ( catch, try ) +import Control.Monad ( when, unless ) +import Control.Exception.Base + +import Foreign +import Foreign.C + +{-# CFILES cbits/directory.c #-} + +import System.Time ( ClockTime(..) ) + +import GHC.IO.Exception ( IOException(..), IOErrorType(..), ioException ) + +import System.Posix.Types +import System.Posix.Internals +import qualified System.Win32 as Win32 + +{- $intro +A directory contains a series of entries, each of which is a named +reference to a file system object (file, directory etc.). Some +entries may be hidden, inaccessible, or have some administrative +function (e.g. `.' or `..' under POSIX +), but in +this standard all such entries are considered to form part of the +directory contents. Entries in sub-directories are not, however, +considered to form part of the directory contents. + +Each file system object is referenced by a /path/. There is +normally at least one absolute path to each file system object. In +some operating systems, it may also be possible to have paths which +are relative to the current directory. +-} + +----------------------------------------------------------------------------- +-- Permissions + +{- $permissions + + The 'Permissions' type is used to record whether certain operations are + permissible on a file\/directory. 'getPermissions' and 'setPermissions' + get and set these permissions, respectively. Permissions apply both to + files and directories. For directories, the executable field will be + 'False', and for files the searchable field will be 'False'. Note that + directories may be searchable without being readable, if permission has + been given to use them as part of a path, but not to examine the + directory contents. + +Note that to change some, but not all permissions, a construct on the following lines must be used. + +> makeReadable f = do +> p <- getPermissions f +> setPermissions f (p {readable = True}) + +-} + +data Permissions + = Permissions { + readable, writable, + executable, searchable :: Bool + } deriving (Eq, Ord, Read, Show) + +{- |The 'getPermissions' operation returns the +permissions for the file or directory. + +The operation may fail with: + +* 'isPermissionError' if the user is not permitted to access + the permissions; or + +* 'isDoesNotExistError' if the file or directory does not exist. + +-} + +getPermissions :: FilePath -> IO Permissions +getPermissions name = do + withFilePath name $ \s -> do + -- stat() does a better job of guessing the permissions on Windows + -- than access() does. e.g. for execute permission, it looks at the + -- filename extension :-) + -- + -- I tried for a while to do this properly, using the Windows security API, + -- and eventually gave up. getPermissions is a flawed API anyway. -- SimonM + allocaBytes sizeof_stat $ \ p_stat -> do + throwErrnoIfMinus1_ "getPermissions" $ c_stat s p_stat + mode <- st_mode p_stat + let usr_read = mode .&. s_IRUSR + let usr_write = mode .&. s_IWUSR + let usr_exec = mode .&. s_IXUSR + let is_dir = mode .&. s_IFDIR + return ( + Permissions { + readable = usr_read /= 0, + writable = usr_write /= 0, + executable = is_dir == 0 && usr_exec /= 0, + searchable = is_dir /= 0 && usr_exec /= 0 + } + ) + +{- |The 'setPermissions' operation sets the +permissions for the file or directory. + +The operation may fail with: + +* 'isPermissionError' if the user is not permitted to set + the permissions; or + +* 'isDoesNotExistError' if the file or directory does not exist. + +-} + +setPermissions :: FilePath -> Permissions -> IO () +setPermissions name (Permissions r w e s) = do + allocaBytes sizeof_stat $ \ p_stat -> do + withFilePath name $ \p_name -> do + throwErrnoIfMinus1_ "setPermissions" $ do + c_stat p_name p_stat + mode <- st_mode p_stat + let mode1 = modifyBit r mode s_IRUSR + let mode2 = modifyBit w mode1 s_IWUSR + let mode3 = modifyBit (e || s) mode2 s_IXUSR + c_wchmod p_name mode3 + where + modifyBit :: Bool -> CMode -> CMode -> CMode + modifyBit False m b = m .&. (complement b) + modifyBit True m b = m .|. b + +foreign import ccall unsafe "_wchmod" + c_wchmod :: CWString -> CMode -> IO CInt + +copyPermissions :: FilePath -> FilePath -> IO () +copyPermissions source dest = do + allocaBytes sizeof_stat $ \ p_stat -> do + withFilePath source $ \p_source -> do + withFilePath dest $ \p_dest -> do + throwErrnoIfMinus1_ "copyPermissions" $ c_stat p_source p_stat + mode <- st_mode p_stat + throwErrnoIfMinus1_ "copyPermissions" $ c_wchmod p_dest mode + +----------------------------------------------------------------------------- +-- Implementation + +{- |@'createDirectory' dir@ creates a new directory @dir@ which is +initially empty, or as near to empty as the operating system +allows. + +The operation may fail with: + +* 'isPermissionError' \/ 'PermissionDenied' +The process has insufficient privileges to perform the operation. +@[EROFS, EACCES]@ + +* 'isAlreadyExistsError' \/ 'AlreadyExists' +The operand refers to a directory that already exists. +@ [EEXIST]@ + +* 'HardwareFault' +A physical I\/O error has occurred. +@[EIO]@ + +* 'InvalidArgument' +The operand is not a valid directory name. +@[ENAMETOOLONG, ELOOP]@ + +* 'NoSuchThing' +There is no path to the directory. +@[ENOENT, ENOTDIR]@ + +* 'ResourceExhausted' +Insufficient resources (virtual memory, process file descriptors, +physical disk space, etc.) are available to perform the operation. +@[EDQUOT, ENOSPC, ENOMEM, EMLINK]@ + +* 'InappropriateType' +The path refers to an existing non-directory object. +@[EEXIST]@ + +-} + +createDirectory :: FilePath -> IO () +createDirectory path = do + Win32.createDirectory path Nothing + +-- | @'createDirectoryIfMissing' parents dir@ creates a new directory +-- @dir@ if it doesn\'t exist. If the first argument is 'True' +-- the function will also create all parent directories if they are missing. +createDirectoryIfMissing :: Bool -- ^ Create its parents too? + -> FilePath -- ^ The path to the directory you want to make + -> IO () +createDirectoryIfMissing create_parents path0 + | create_parents = createDirs (parents path0) + | otherwise = createDirs (take 1 (parents path0)) + where + parents = reverse . scanl1 () . splitDirectories . normalise + + createDirs [] = return () + createDirs (dir:[]) = createDir dir throw + createDirs (dir:dirs) = + createDir dir $ \_ -> do + createDirs dirs + createDir dir throw + + createDir :: FilePath -> (IOException -> IO ()) -> IO () + createDir dir notExistHandler = do + r <- try $ createDirectory dir + case (r :: Either IOException ()) of + Right () -> return () + Left e + | isDoesNotExistError e -> notExistHandler e + -- createDirectory (and indeed POSIX mkdir) does not distinguish + -- between a dir already existing and a file already existing. So we + -- check for it here. Unfortunately there is a slight race condition + -- here, but we think it is benign. It could report an exeption in + -- the case that the dir did exist but another process deletes the + -- directory and creates a file in its place before we can check + -- that the directory did indeed exist. + | isAlreadyExistsError e -> (do + withFileStatus "createDirectoryIfMissing" dir $ \st -> do + isDir <- isDirectory st + if isDir then return () + else throw e + ) `catch` ((\_ -> return ()) :: IOException -> IO ()) + | otherwise -> throw e + +{- | @'removeDirectory' dir@ removes an existing directory /dir/. The +implementation may specify additional constraints which must be +satisfied before a directory can be removed (e.g. the directory has to +be empty, or may not be in use by other processes). It is not legal +for an implementation to partially remove a directory unless the +entire directory is removed. A conformant implementation need not +support directory removal in all situations (e.g. removal of the root +directory). + +The operation may fail with: + +* 'HardwareFault' +A physical I\/O error has occurred. +EIO + +* 'InvalidArgument' +The operand is not a valid directory name. +[ENAMETOOLONG, ELOOP] + +* 'isDoesNotExistError' \/ 'NoSuchThing' +The directory does not exist. +@[ENOENT, ENOTDIR]@ + +* 'isPermissionError' \/ 'PermissionDenied' +The process has insufficient privileges to perform the operation. +@[EROFS, EACCES, EPERM]@ + +* 'UnsatisfiedConstraints' +Implementation-dependent constraints are not satisfied. +@[EBUSY, ENOTEMPTY, EEXIST]@ + +* 'UnsupportedOperation' +The implementation does not support removal in this situation. +@[EINVAL]@ + +* 'InappropriateType' +The operand refers to an existing non-directory object. +@[ENOTDIR]@ + +-} + +removeDirectory :: FilePath -> IO () +removeDirectory path = + Win32.removeDirectory path + +-- | @'removeDirectoryRecursive' dir@ removes an existing directory /dir/ +-- together with its content and all subdirectories. Be careful, +-- if the directory contains symlinks, the function will follow them. +removeDirectoryRecursive :: FilePath -> IO () +removeDirectoryRecursive startLoc = do + cont <- getDirectoryContents startLoc + sequence_ [rm (startLoc x) | x <- cont, x /= "." && x /= ".."] + removeDirectory startLoc + where + rm :: FilePath -> IO () + rm f = do temp <- try (removeFile f) + case temp of + Left e -> do isDir <- doesDirectoryExist f + -- If f is not a directory, re-throw the error + unless isDir $ throw (e :: SomeException) + removeDirectoryRecursive f + Right _ -> return () + +{- |'removeFile' /file/ removes the directory entry for an existing file +/file/, where /file/ is not itself a directory. The +implementation may specify additional constraints which must be +satisfied before a file can be removed (e.g. the file may not be in +use by other processes). + +The operation may fail with: + +* 'HardwareFault' +A physical I\/O error has occurred. +@[EIO]@ + +* 'InvalidArgument' +The operand is not a valid file name. +@[ENAMETOOLONG, ELOOP]@ + +* 'isDoesNotExistError' \/ 'NoSuchThing' +The file does not exist. +@[ENOENT, ENOTDIR]@ + +* 'isPermissionError' \/ 'PermissionDenied' +The process has insufficient privileges to perform the operation. +@[EROFS, EACCES, EPERM]@ + +* 'UnsatisfiedConstraints' +Implementation-dependent constraints are not satisfied. +@[EBUSY]@ + +* 'InappropriateType' +The operand refers to an existing directory. +@[EPERM, EINVAL]@ + +-} + +removeFile :: FilePath -> IO () +removeFile path = + Win32.deleteFile path + +{- |@'renameDirectory' old new@ changes the name of an existing +directory from /old/ to /new/. If the /new/ directory +already exists, it is atomically replaced by the /old/ directory. +If the /new/ directory is neither the /old/ directory nor an +alias of the /old/ directory, it is removed as if by +'removeDirectory'. A conformant implementation need not support +renaming directories in all situations (e.g. renaming to an existing +directory, or across different physical devices), but the constraints +must be documented. + +On Win32 platforms, @renameDirectory@ fails if the /new/ directory already +exists. + +The operation may fail with: + +* 'HardwareFault' +A physical I\/O error has occurred. +@[EIO]@ + +* 'InvalidArgument' +Either operand is not a valid directory name. +@[ENAMETOOLONG, ELOOP]@ + +* 'isDoesNotExistError' \/ 'NoSuchThing' +The original directory does not exist, or there is no path to the target. +@[ENOENT, ENOTDIR]@ + +* 'isPermissionError' \/ 'PermissionDenied' +The process has insufficient privileges to perform the operation. +@[EROFS, EACCES, EPERM]@ + +* 'ResourceExhausted' +Insufficient resources are available to perform the operation. +@[EDQUOT, ENOSPC, ENOMEM, EMLINK]@ + +* 'UnsatisfiedConstraints' +Implementation-dependent constraints are not satisfied. +@[EBUSY, ENOTEMPTY, EEXIST]@ + +* 'UnsupportedOperation' +The implementation does not support renaming in this situation. +@[EINVAL, EXDEV]@ + +* 'InappropriateType' +Either path refers to an existing non-directory object. +@[ENOTDIR, EISDIR]@ + +-} + +renameDirectory :: FilePath -> FilePath -> IO () +renameDirectory opath npath = do + -- XXX this test isn't performed atomically with the following rename + -- ToDo: use Win32 API + withFileStatus "renameDirectory" opath $ \st -> do + is_dir <- isDirectory st + if (not is_dir) + then ioException (ioeSetErrorString + (mkIOError InappropriateType "renameDirectory" Nothing (Just opath)) + "not a directory") + else do + Win32.moveFileEx opath npath Win32.mOVEFILE_REPLACE_EXISTING + +{- |@'renameFile' old new@ changes the name of an existing file system +object from /old/ to /new/. If the /new/ object already +exists, it is atomically replaced by the /old/ object. Neither +path may refer to an existing directory. A conformant implementation +need not support renaming files in all situations (e.g. renaming +across different physical devices), but the constraints must be +documented. + +The operation may fail with: + +* 'HardwareFault' +A physical I\/O error has occurred. +@[EIO]@ + +* 'InvalidArgument' +Either operand is not a valid file name. +@[ENAMETOOLONG, ELOOP]@ + +* 'isDoesNotExistError' \/ 'NoSuchThing' +The original file does not exist, or there is no path to the target. +@[ENOENT, ENOTDIR]@ + +* 'isPermissionError' \/ 'PermissionDenied' +The process has insufficient privileges to perform the operation. +@[EROFS, EACCES, EPERM]@ + +* 'ResourceExhausted' +Insufficient resources are available to perform the operation. +@[EDQUOT, ENOSPC, ENOMEM, EMLINK]@ + +* 'UnsatisfiedConstraints' +Implementation-dependent constraints are not satisfied. +@[EBUSY]@ + +* 'UnsupportedOperation' +The implementation does not support renaming in this situation. +@[EXDEV]@ + +* 'InappropriateType' +Either path refers to an existing directory. +@[ENOTDIR, EISDIR, EINVAL, EEXIST, ENOTEMPTY]@ + +-} + +renameFile :: FilePath -> FilePath -> IO () +renameFile opath npath = do + -- XXX this test isn't performed atomically with the following rename + -- ToDo: use Win32 API + withFileOrSymlinkStatus "renameFile" opath $ \st -> do + is_dir <- isDirectory st + if is_dir + then ioException (ioeSetErrorString + (mkIOError InappropriateType "renameFile" Nothing (Just opath)) + "is a directory") + else do + Win32.moveFileEx opath npath Win32.mOVEFILE_REPLACE_EXISTING + +{- |@'copyFile' old new@ copies the existing file from /old/ to /new/. +If the /new/ file already exists, it is atomically replaced by the /old/ file. +Neither path may refer to an existing directory. The permissions of /old/ are +copied to /new/, if possible. +-} + +copyFile :: FilePath -> FilePath -> IO () +copyFile fromFPath toFPath = + copy `Prelude.catch` (\exc -> throw $ ioeSetLocation exc "copyFile") + where copy = bracket (openBinaryFile fromFPath ReadMode) hClose $ \hFrom -> + bracketOnError openTmp cleanTmp $ \(tmpFPath, hTmp) -> + do allocaBytes bufferSize $ copyContents hFrom hTmp + hClose hTmp + ignoreIOExceptions $ copyPermissions fromFPath tmpFPath + renameFile tmpFPath toFPath + openTmp = openBinaryTempFile (takeDirectory toFPath) ".copyFile.tmp" + cleanTmp (tmpFPath, hTmp) + = do ignoreIOExceptions $ hClose hTmp + ignoreIOExceptions $ removeFile tmpFPath + bufferSize = 1024 + + copyContents hFrom hTo buffer = do + count <- hGetBuf hFrom buffer bufferSize + when (count > 0) $ do + hPutBuf hTo buffer count + copyContents hFrom hTo buffer + + ignoreIOExceptions io = io `catch` ioExceptionIgnorer + ioExceptionIgnorer :: IOException -> IO () + ioExceptionIgnorer _ = return () + +-- | Given path referring to a file or directory, returns a +-- canonicalized path, with the intent that two paths referring +-- to the same file\/directory will map to the same canonicalized +-- path. Note that it is impossible to guarantee that the +-- implication (same file\/dir \<=\> same canonicalizedPath) holds +-- in either direction: this function can make only a best-effort +-- attempt. +canonicalizePath :: FilePath -> IO FilePath +canonicalizePath fpath = + do path <- Win32.getFullPathName fpath + return (normalise path) + -- normalise does more stuff, like upper-casing the drive letter + + +-- | 'makeRelative' the current directory. +makeRelativeToCurrentDirectory :: FilePath -> IO FilePath +makeRelativeToCurrentDirectory x = do + cur <- getCurrentDirectory + return $ makeRelative cur x + +-- | Given an executable file name, searches for such file in the +-- directories listed in system PATH. The returned value is the path +-- to the found executable or Nothing if an executable with the given +-- name was not found. For example (findExecutable \"ghc\") gives you +-- the path to GHC. +-- +-- The path returned by 'findExecutable' corresponds to the +-- program that would be executed by 'System.Process.createProcess' +-- when passed the same string (as a RawCommand, not a ShellCommand). +-- +-- On Windows, 'findExecutable' calls the Win32 function 'SearchPath', +-- which may search other places before checking the directories in +-- @PATH@. Where it actually searches depends on registry settings, +-- but notably includes the directory containing the current +-- executable. See +-- for more +-- details. +-- +findExecutable :: String -> IO (Maybe FilePath) +findExecutable binary = + Win32.searchPath Nothing binary ('.':exeExtension) + + +{- |@'getDirectoryContents' dir@ returns a list of /all/ entries +in /dir/. + +The operation may fail with: + +* 'HardwareFault' +A physical I\/O error has occurred. +@[EIO]@ + +* 'InvalidArgument' +The operand is not a valid directory name. +@[ENAMETOOLONG, ELOOP]@ + +* 'isDoesNotExistError' \/ 'NoSuchThing' +The directory does not exist. +@[ENOENT, ENOTDIR]@ + +* 'isPermissionError' \/ 'PermissionDenied' +The process has insufficient privileges to perform the operation. +@[EACCES]@ + +* 'ResourceExhausted' +Insufficient resources are available to perform the operation. +@[EMFILE, ENFILE]@ + +* 'InappropriateType' +The path refers to an existing non-directory object. +@[ENOTDIR]@ + +-} + +getDirectoryContents :: FilePath -> IO [FilePath] +getDirectoryContents path = + modifyIOError ((`ioeSetFileName` path) . + (`ioeSetLocation` "getDirectoryContents")) $ do + bracket + (Win32.findFirstFile (path "*")) + (\(h,_) -> Win32.findClose h) + (\(h,fdat) -> loop h fdat []) + where + -- we needn't worry about empty directories: adirectory always + -- has at least "." and ".." entries + loop :: Win32.HANDLE -> Win32.FindData -> [FilePath] -> IO [FilePath] + loop h fdat acc = do + filename <- Win32.getFindDataFileName fdat + more <- Win32.findNextFile h fdat + if more + then loop h fdat (filename:acc) + else return (filename:acc) + -- no need to reverse, ordering is undefined + +{- |If the operating system has a notion of current directories, +'getCurrentDirectory' returns an absolute path to the +current directory of the calling process. + +The operation may fail with: + +* 'HardwareFault' +A physical I\/O error has occurred. +@[EIO]@ + +* 'isDoesNotExistError' \/ 'NoSuchThing' +There is no path referring to the current directory. +@[EPERM, ENOENT, ESTALE...]@ + +* 'isPermissionError' \/ 'PermissionDenied' +The process has insufficient privileges to perform the operation. +@[EACCES]@ + +* 'ResourceExhausted' +Insufficient resources are available to perform the operation. + +* 'UnsupportedOperation' +The operating system has no notion of current directory. + +-} +getCurrentDirectory :: IO FilePath +getCurrentDirectory = do + Win32.getCurrentDirectory + +{- |If the operating system has a notion of current directories, +@'setCurrentDirectory' dir@ changes the current +directory of the calling process to /dir/. + +The operation may fail with: + +* 'HardwareFault' +A physical I\/O error has occurred. +@[EIO]@ + +* 'InvalidArgument' +The operand is not a valid directory name. +@[ENAMETOOLONG, ELOOP]@ + +* 'isDoesNotExistError' \/ 'NoSuchThing' +The directory does not exist. +@[ENOENT, ENOTDIR]@ + +* 'isPermissionError' \/ 'PermissionDenied' +The process has insufficient privileges to perform the operation. +@[EACCES]@ + +* 'UnsupportedOperation' +The operating system has no notion of current directory, or the +current directory cannot be dynamically changed. + +* 'InappropriateType' +The path refers to an existing non-directory object. +@[ENOTDIR]@ + +-} + +setCurrentDirectory :: FilePath -> IO () +setCurrentDirectory path = + Win32.setCurrentDirectory path + +{- |The operation 'doesDirectoryExist' returns 'True' if the argument file +exists and is a directory, and 'False' otherwise. +-} + +doesDirectoryExist :: FilePath -> IO Bool +doesDirectoryExist name = + (withFileStatus "doesDirectoryExist" name $ \st -> isDirectory st) + `catch` ((\ _ -> return False) :: IOException -> IO Bool) + +{- |The operation 'doesFileExist' returns 'True' +if the argument file exists and is not a directory, and 'False' otherwise. +-} + +doesFileExist :: FilePath -> IO Bool +doesFileExist name = + (withFileStatus "doesFileExist" name $ \st -> do b <- isDirectory st; return (not b)) + `catch` ((\ _ -> return False) :: IOException -> IO Bool) + +{- |The 'getModificationTime' operation returns the +clock time at which the file or directory was last modified. + +The operation may fail with: + +* 'isPermissionError' if the user is not permitted to access + the modification time; or + +* 'isDoesNotExistError' if the file or directory does not exist. + +-} + +getModificationTime :: FilePath -> IO ClockTime +getModificationTime name = do + -- ToDo: use Win32 API + withFileStatus "getModificationTime" name $ \ st -> do + modificationTime st + + +withFileStatus :: String -> FilePath -> (Ptr CStat -> IO a) -> IO a +withFileStatus loc name f = do + modifyIOError (`ioeSetFileName` name) $ + allocaBytes sizeof_stat $ \p -> + withFilePath (fileNameEndClean name) $ \s -> do + throwErrnoIfMinus1Retry_ loc (c_stat s p) + +withFileOrSymlinkStatus :: String -> FilePath -> (Ptr CStat -> IO a) -> IO a +withFileOrSymlinkStatus loc name f = do + modifyIOError (`ioeSetFileName` name) $ + allocaBytes sizeof_stat $ \p -> + withFilePath name $ \s -> do + throwErrnoIfMinus1Retry_ loc (lstat s p) + +modificationTime :: Ptr CStat -> IO ClockTime +modificationTime stat = do + mtime <- st_mtime stat + let realToInteger = round . realToFrac :: Real a => a -> Integer + return (TOD (realToInteger (mtime :: CTime)) 0) + +isDirectory :: Ptr CStat -> IO Bool +isDirectory stat = do + mode <- st_mode stat + return (s_isdir mode) + +fileNameEndClean :: String -> String +fileNameEndClean name = if isDrive name then addTrailingPathSeparator name + else dropTrailingPathSeparator name + +foreign import ccall unsafe "HsDirectory.h __hscore_S_IRUSR" s_IRUSR :: CMode +foreign import ccall unsafe "HsDirectory.h __hscore_S_IWUSR" s_IWUSR :: CMode +foreign import ccall unsafe "HsDirectory.h __hscore_S_IXUSR" s_IXUSR :: CMode +foreign import ccall unsafe "__hscore_S_IFDIR" s_IFDIR :: CMode + + +foreign import ccall unsafe "__hscore_long_path_size" + long_path_size :: Int + +{- | Returns the current user's home directory. + +The directory returned is expected to be writable by the current user, +but note that it isn't generally considered good practice to store +application-specific data here; use 'getAppUserDataDirectory' +instead. + +On Unix, 'getHomeDirectory' returns the value of the @HOME@ +environment variable. On Windows, the system is queried for a +suitable path; a typical path might be +@C:/Documents And Settings/user@. + +The operation may fail with: + +* 'UnsupportedOperation' +The operating system has no notion of home directory. + +* 'isDoesNotExistError' +The home directory for the current user does not exist, or +cannot be found. +-} +getHomeDirectory :: IO FilePath +getHomeDirectory = + modifyIOError ((`ioeSetLocation` "getHomeDirectory")) $ do + r <- try $ Win32.sHGetFolderPath nullPtr Win32.cSIDL_PROFILE nullPtr 0 + case (r :: Either IOException String) of + Right s -> return s + Left _ -> do + r1 <- try $ Win32.sHGetFolderPath nullPtr Win32.cSIDL_WINDOWS nullPtr 0 + case r1 of + Right s -> return s + Left e -> ioError (e :: IOException) + +{- | Returns the pathname of a directory in which application-specific +data for the current user can be stored. The result of +'getAppUserDataDirectory' for a given application is specific to +the current user. + +The argument should be the name of the application, which will be used +to construct the pathname (so avoid using unusual characters that +might result in an invalid pathname). + +Note: the directory may not actually exist, and may need to be created +first. It is expected that the parent directory exists and is +writable. + +On Unix, this function returns @$HOME\/.appName@. On Windows, a +typical path might be + +> C:/Documents And Settings/user/Application Data/appName + +The operation may fail with: + +* 'UnsupportedOperation' +The operating system has no notion of application-specific data directory. + +* 'isDoesNotExistError' +The home directory for the current user does not exist, or +cannot be found. +-} +getAppUserDataDirectory :: String -> IO FilePath +getAppUserDataDirectory appName = do + modifyIOError ((`ioeSetLocation` "getAppUserDataDirectory")) $ do + s <- Win32.sHGetFolderPath nullPtr Win32.cSIDL_APPDATA nullPtr 0 + return (s++'\\':appName) + +{- | Returns the current user's document directory. + +The directory returned is expected to be writable by the current user, +but note that it isn't generally considered good practice to store +application-specific data here; use 'getAppUserDataDirectory' +instead. + +On Unix, 'getUserDocumentsDirectory' returns the value of the @HOME@ +environment variable. On Windows, the system is queried for a +suitable path; a typical path might be +@C:\/Documents and Settings\/user\/My Documents@. + +The operation may fail with: + +* 'UnsupportedOperation' +The operating system has no notion of document directory. + +* 'isDoesNotExistError' +The document directory for the current user does not exist, or +cannot be found. +-} +getUserDocumentsDirectory :: IO FilePath +getUserDocumentsDirectory = do + modifyIOError ((`ioeSetLocation` "getUserDocumentsDirectory")) $ do + Win32.sHGetFolderPath nullPtr Win32.cSIDL_PERSONAL nullPtr 0 + +{- | Returns the current directory for temporary files. + +On Unix, 'getTemporaryDirectory' returns the value of the @TMPDIR@ +environment variable or \"\/tmp\" if the variable isn\'t defined. +On Windows, the function checks for the existence of environment variables in +the following order and uses the first path found: + +* +TMP environment variable. + +* +TEMP environment variable. + +* +USERPROFILE environment variable. + +* +The Windows directory + +The operation may fail with: + +* 'UnsupportedOperation' +The operating system has no notion of temporary directory. + +The function doesn\'t verify whether the path exists. +-} +getTemporaryDirectory :: IO FilePath +getTemporaryDirectory = do + Win32.getTemporaryDirectory + +-- ToDo: This should be determined via autoconf (AC_EXEEXT) +-- | Extension for executable files +-- (typically @\"\"@ on Unix and @\"exe\"@ on Windows or OS\/2) +exeExtension :: String +exeExtension = "exe" diff --git a/Test/examples/EmptyAnn.hs b/Test/examples/EmptyAnn.hs new file mode 100644 --- /dev/null +++ b/Test/examples/EmptyAnn.hs @@ -0,0 +1,1 @@ +{-# ANN foo "Hlint: ignore Test4" #-} diff --git a/Test/examples/EmptyContext.hs b/Test/examples/EmptyContext.hs new file mode 100644 --- /dev/null +++ b/Test/examples/EmptyContext.hs @@ -0,0 +1,1 @@ +happyThen :: () => P a diff --git a/Test/examples/EmptyInstance.hs b/Test/examples/EmptyInstance.hs new file mode 100644 --- /dev/null +++ b/Test/examples/EmptyInstance.hs @@ -0,0 +1,4 @@ +instance Traversable Tree where + +x :: Int +x = 1 diff --git a/Test/examples/EmptyList.hs b/Test/examples/EmptyList.hs new file mode 100644 --- /dev/null +++ b/Test/examples/EmptyList.hs @@ -0,0 +1,3 @@ +module EmptyList where + +eAttrs = [] diff --git a/Test/examples/Ex1.hs b/Test/examples/Ex1.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Ex1.hs @@ -0,0 +1,1 @@ +yes = 1 where x = 1 diff --git a/Test/examples/FamilyKindSig.hs b/Test/examples/FamilyKindSig.hs new file mode 100644 --- /dev/null +++ b/Test/examples/FamilyKindSig.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE TypeFamilies #-} +module FamilyKindSig where + +type family WithKindSig (a :: * -> *) diff --git a/Test/examples/FixityTests.hs b/Test/examples/FixityTests.hs new file mode 100644 --- /dev/null +++ b/Test/examples/FixityTests.hs @@ -0,0 +1,3 @@ +main = forM_ cmdReports $ \x -> do + putStrLn $ "Writing report to " ++ x ++ " ..." + writeReport x ideas diff --git a/Test/examples/ForeignImport.hs b/Test/examples/ForeignImport.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ForeignImport.hs @@ -0,0 +1,2 @@ +foreign import ccall unsafe "getProgArgv" + getProgArgv :: Ptr CInt -> Ptr (Ptr CString) -> IO () diff --git a/Test/examples/GadtDeriving.hs b/Test/examples/GadtDeriving.hs new file mode 100644 --- /dev/null +++ b/Test/examples/GadtDeriving.hs @@ -0,0 +1,5 @@ +{-# LANGUAGE GADTs #-} + +data Foo where + Foo :: Int -> Foo + deriving (Eq,Ord,Typeable) diff --git a/Test/examples/GenericTree.hs b/Test/examples/GenericTree.hs new file mode 100644 --- /dev/null +++ b/Test/examples/GenericTree.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE RankNTypes #-} +module GenericTree where + +import Data.Typeable + +dynRep :: (Typeable a) => a -> (TypeRep, forall b. (Typeable b) => b -> (Maybe b)) +dynRep a = (typeOf a, \_ -> cast a) diff --git a/Test/examples/GhcDeriving.hs b/Test/examples/GhcDeriving.hs new file mode 100644 --- /dev/null +++ b/Test/examples/GhcDeriving.hs @@ -0,0 +1,4 @@ + + +newtype CodeGenModule a = CGM (StateT CGMState IO a) + deriving (Monad, MonadState [s], MonadIO) diff --git a/Test/examples/GroupKeyword.hs b/Test/examples/GroupKeyword.hs new file mode 100644 --- /dev/null +++ b/Test/examples/GroupKeyword.hs @@ -0,0 +1,4 @@ +-- {-# LANGUAGE TransformListComp #-} +module GroupKeyword where + +a = map head $ group $ sort [1..100] diff --git a/Test/examples/HappyDoAction.hs b/Test/examples/HappyDoAction.hs new file mode 100644 --- /dev/null +++ b/Test/examples/HappyDoAction.hs @@ -0,0 +1,30 @@ +{-# LANGUAGE MagicHash #-} +module HappyDoAction where + +foo :: Int# + +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 diff --git a/Test/examples/HaskellParser.hs b/Test/examples/HaskellParser.hs new file mode 100644 --- /dev/null +++ b/Test/examples/HaskellParser.hs @@ -0,0 +1,16 @@ +import qualified Language.Haskell.Exts.Annotated as Parser +import qualified Language.Haskell.Exts.Annotated.Syntax as Syn +import qualified Language.Haskell.Exts.Extension as Ext + +parse originalFileName input = Parser.parseModuleWithMode parseMode input + where + parseMode :: Parser.ParseMode + parseMode = Parser.defaultParseMode { Parser.parseFilename = originalFileName + , Parser.extensions = + Ext.glasgowExts ++ + [Ext.ExplicitForall] + } +main = + do s <- readFile "Bug.hs" + let x = parse "Bug.hs" s + putStrLn (show x) diff --git a/Test/examples/HexPrec.hs b/Test/examples/HexPrec.hs new file mode 100644 --- /dev/null +++ b/Test/examples/HexPrec.hs @@ -0,0 +1,6 @@ +module HexPrec where + +(%%) :: Int -> Int -> Int +a %% b = 0 + +infixl 0x02 %% diff --git a/Test/examples/Hyphen.hs b/Test/examples/Hyphen.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Hyphen.hs @@ -0,0 +1,2 @@ + +foo x y = fromIntegral $ x-y+1 diff --git a/Test/examples/ImportSymbol.hs b/Test/examples/ImportSymbol.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ImportSymbol.hs @@ -0,0 +1,1 @@ +import Data.Generics hiding ((:*:)) diff --git a/Test/examples/IndentedWhere.hs b/Test/examples/IndentedWhere.hs new file mode 100644 --- /dev/null +++ b/Test/examples/IndentedWhere.hs @@ -0,0 +1,4 @@ + +f x = g + where g :: Int + g = 0 diff --git a/Test/examples/InfixParser.hs b/Test/examples/InfixParser.hs new file mode 100644 --- /dev/null +++ b/Test/examples/InfixParser.hs @@ -0,0 +1,6 @@ +module InfixParser where + +type Parse a b = [a] -> [(b, [a])] + +(<|>) :: Parse a b -> Parse a b -> Parse a b +(p1 <|> p2) i = p1 i ++ p2 i diff --git a/Test/examples/LanguagePragma.hs b/Test/examples/LanguagePragma.hs new file mode 100644 --- /dev/null +++ b/Test/examples/LanguagePragma.hs @@ -0,0 +1,1 @@ +{-# LANGUAGE PatternGuards, ViewPatterns #-} diff --git a/Test/examples/LineOptionsPragma.hs b/Test/examples/LineOptionsPragma.hs new file mode 100644 --- /dev/null +++ b/Test/examples/LineOptionsPragma.hs @@ -0,0 +1,3 @@ +{-# OPTIONS #-} +{-# LINE 49 "src/Language/C/Parser/Lexer.x" #-} +module Fail where diff --git a/Test/examples/LinePragma.hs b/Test/examples/LinePragma.hs new file mode 100644 --- /dev/null +++ b/Test/examples/LinePragma.hs @@ -0,0 +1,5 @@ +{-# LINE 1 "Algebra.lhs" #-} +module Algebra where + +{-# LINE 3 "Algebra.lhs" #-} +foo bar = bar diff --git a/Test/examples/ListComp1.hs b/Test/examples/ListComp1.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ListComp1.hs @@ -0,0 +1,1 @@ +copyFiles = [a | f ('.':)] diff --git a/Test/examples/MagicHash.hs b/Test/examples/MagicHash.hs new file mode 100644 --- /dev/null +++ b/Test/examples/MagicHash.hs @@ -0,0 +1,12 @@ +{-# LANGUAGE MagicHash #-} + +import GHC.Exts + +putByteArray :: Int# -> Int# +putByteArray s# = s# +# 1# + +floatFoo :: Float# -> Float +floatFoo f# = F# (f# `plusFloat#` 1.2e2#) + +charFun :: Char# -> Bool +charFun c# = c# `gtChar#` 'a'# diff --git a/Test/examples/MultiCtxt.hs b/Test/examples/MultiCtxt.hs new file mode 100644 --- /dev/null +++ b/Test/examples/MultiCtxt.hs @@ -0,0 +1,6 @@ +{-# LANGUAGE RankNTypes #-} + +module MultiCtxt where + +multipleCtx :: Eq a => (Show a => a) +multipleCtx = undefined diff --git a/Test/examples/NPlusK.hs b/Test/examples/NPlusK.hs new file mode 100644 --- /dev/null +++ b/Test/examples/NPlusK.hs @@ -0,0 +1,2 @@ + +f (n+3) = n diff --git a/Test/examples/NestedAsPat.hs b/Test/examples/NestedAsPat.hs new file mode 100644 --- /dev/null +++ b/Test/examples/NestedAsPat.hs @@ -0,0 +1,3 @@ +module NestedAsPat where + +nestedAsPat [x@(Just _)] = undefined diff --git a/Test/examples/PackageImport.hs b/Test/examples/PackageImport.hs new file mode 100644 --- /dev/null +++ b/Test/examples/PackageImport.hs @@ -0,0 +1,5 @@ +{-# LANGUAGE PackageImports #-} + +import "haskell-src-exts" Language.Haskell.Exts + +main = undefined diff --git a/Test/examples/ParenFunBind.hs b/Test/examples/ParenFunBind.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ParenFunBind.hs @@ -0,0 +1,3 @@ +module ParenFunBind where + +(foo x) y = x + y diff --git a/Test/examples/Pragma.hs b/Test/examples/Pragma.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Pragma.hs @@ -0,0 +1,7 @@ + + +data Bar = Bar + +instance Eq Bar where + {-# INLINE (==) #-} + a == b = error "here" diff --git a/Test/examples/QualifiedDot.hs b/Test/examples/QualifiedDot.hs new file mode 100644 --- /dev/null +++ b/Test/examples/QualifiedDot.hs @@ -0,0 +1,3 @@ +module QualifiedDot where + +twoDots = (Prelude..) diff --git a/Test/examples/QuasiQuoteLines.hs b/Test/examples/QuasiQuoteLines.hs new file mode 100644 --- /dev/null +++ b/Test/examples/QuasiQuoteLines.hs @@ -0,0 +1,12 @@ +{-# LANGUAGE QuasiQuotes #-} + +import Here + +str :: String +str = [$here|test +test +test test |] + + +main :: IO() +main = do putStrLn str diff --git a/Test/examples/Rank2Types.hs b/Test/examples/Rank2Types.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Rank2Types.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE Rank2Types #-} + +test :: Int -> forall a. [a] -> Int +test _ _ = 1 diff --git a/Test/examples/ReadP.hs b/Test/examples/ReadP.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ReadP.hs @@ -0,0 +1,2 @@ +{-# LANGUAGE TypeOperators #-} +newtype ReadP a = R (forall b . (a -> P b) -> P b) diff --git a/Test/examples/RealGHC.lhs b/Test/examples/RealGHC.lhs new file mode 100644 --- /dev/null +++ b/Test/examples/RealGHC.lhs @@ -0,0 +1,913 @@ +% +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 +% +\section[CoreRules]{Transformation rules} + +\begin{code} +{-# OPTIONS -w #-} +{-# LANGUAGE PatternGuards #-} +-- The above warning supression flag is a temporary kludge. +-- While working on this module you are encouraged to remove it and fix +-- any warnings in the module. See +-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings +-- for details + +-- | Functions for collecting together and applying rewrite rules to a module. +-- The 'CoreRule' datatype itself is declared elsewhere. +module Rules ( + -- * RuleBase + RuleBase, + + -- ** Constructing + emptyRuleBase, mkRuleBase, extendRuleBaseList, + unionRuleBase, pprRuleBase, + + -- ** Checking rule applications + ruleCheckProgram, + + -- ** Manipulating 'SpecInfo' rules + mkSpecInfo, extendSpecInfo, addSpecInfo, + addIdSpecialisations, + + -- * Misc. CoreRule helpers + rulesOfBinds, getRules, pprRulesForUser, + + lookupRule, mkLocalRule, roughTopNames + ) where + +-- #include "HsVersions.h" + +import CoreSyn -- All of it +import OccurAnal ( occurAnalyseExpr ) +import CoreFVs ( exprFreeVars, exprsFreeVars, bindFreeVars, rulesFreeVars ) +import CoreUtils ( tcEqExprX, exprType ) +import PprCore ( pprRules ) +import Type ( Type, TvSubstEnv ) +import Coercion ( coercionKind ) +import TcType ( tcSplitTyConApp_maybe ) +import CoreTidy ( tidyRules ) +import Id +import IdInfo ( SpecInfo( SpecInfo ) ) +import Var ( Var ) +import VarEnv +import VarSet +import Name ( Name, NamedThing(..) ) +import NameEnv +import Unify ( ruleMatchTyX, MatchEnv(..) ) +import BasicTypes ( Activation ) +import StaticFlags ( opt_PprStyle_Debug ) +import Outputable +import FastString +import Maybes +import OrdList +import Bag +import Util +import Data.List +\end{code} + + +%************************************************************************ +%* * +\subsection[specialisation-IdInfo]{Specialisation info about an @Id@} +%* * +%************************************************************************ + +A @CoreRule@ holds details of one rule for an @Id@, which +includes its specialisations. + +For example, if a rule for @f@ contains the mapping: +\begin{verbatim} + forall a b d. [Type (List a), Type b, Var d] ===> f' a b +\end{verbatim} +then when we find an application of f to matching types, we simply replace +it by the matching RHS: +\begin{verbatim} + f (List Int) Bool dict ===> f' Int Bool +\end{verbatim} +All the stuff about how many dictionaries to discard, and what types +to apply the specialised function to, are handled by the fact that the +Rule contains a template for the result of the specialisation. + +There is one more exciting case, which is dealt with in exactly the same +way. If the specialised value is unboxed then it is lifted at its +definition site and unlifted at its uses. For example: + + pi :: forall a. Num a => a + +might have a specialisation + + [Int#] ===> (case pi' of Lift pi# -> pi#) + +where pi' :: Lift Int# is the specialised version of pi. + +\begin{code} +mkLocalRule :: RuleName -> Activation + -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule +-- ^ Used to make 'CoreRule' for an 'Id' defined in the module being +-- compiled. See also 'CoreSyn.CoreRule' +mkLocalRule name act fn bndrs args rhs + = Rule { ru_name = name, ru_fn = fn, ru_act = act, + ru_bndrs = bndrs, ru_args = args, + ru_rhs = rhs, ru_rough = roughTopNames args, + ru_local = True } + +-------------- +roughTopNames :: [CoreExpr] -> [Maybe Name] +-- ^ Find the \"top\" free names of several expressions. +-- Such names are either: +-- +-- 1. The function finally being applied to in an application chain +-- (if that name is a GlobalId: see "Var#globalvslocal"), or +-- +-- 2. The 'TyCon' if the expression is a 'Type' +-- +-- This is used for the fast-match-check for rules; +-- if the top names don't match, the rest can't +roughTopNames args = map roughTopName args + +roughTopName :: CoreExpr -> Maybe Name +roughTopName (Type ty) = case tcSplitTyConApp_maybe ty of + Just (tc,_) -> Just (getName tc) + Nothing -> Nothing +roughTopName (App f a) = roughTopName f +roughTopName (Var f) | isGlobalId f = Just (idName f) + | otherwise = Nothing +roughTopName other = Nothing + +ruleCantMatch :: [Maybe Name] -> [Maybe Name] -> Bool +-- ^ @ruleCantMatch tpl actual@ returns True only if @actual@ +-- definitely can't match @tpl@ by instantiating @tpl@. +-- It's only a one-way match; unlike instance matching we +-- don't consider unification. +-- +-- Notice that [_$_] +-- @ruleCantMatch [Nothing] [Just n2] = False@ +-- Reason: a template variable can be instantiated by a constant +-- Also: +-- @ruleCantMatch [Just n1] [Nothing] = False@ +-- Reason: a local variable @v@ in the actuals might [_$_] + +ruleCantMatch (Just n1 : ts) (Just n2 : as) = n1 /= n2 || ruleCantMatch ts as +ruleCantMatch (t : ts) (a : as) = ruleCantMatch ts as +ruleCantMatch ts as = False +\end{code} + +\begin{code} +pprRulesForUser :: [CoreRule] -> SDoc +-- (a) tidy the rules +-- (b) sort them into order based on the rule name +-- (c) suppress uniques (unless -dppr-debug is on) +-- This combination makes the output stable so we can use in testing +-- It's here rather than in PprCore because it calls tidyRules +pprRulesForUser rules + = withPprStyle defaultUserStyle $ + pprRules $ + sortLe le_rule $ + tidyRules emptyTidyEnv rules + where + le_rule r1 r2 = ru_name r1 <= ru_name r2 +\end{code} + + +%************************************************************************ +%* * + SpecInfo: the rules in an IdInfo +%* * +%************************************************************************ + +\begin{code} +-- | Make a 'SpecInfo' containing a number of 'CoreRule's, suitable +-- for putting into an 'IdInfo' +mkSpecInfo :: [CoreRule] -> SpecInfo +mkSpecInfo rules = SpecInfo rules (rulesFreeVars rules) + +extendSpecInfo :: SpecInfo -> [CoreRule] -> SpecInfo +extendSpecInfo (SpecInfo rs1 fvs1) rs2 + = SpecInfo (rs2 ++ rs1) (rulesFreeVars rs2 `unionVarSet` fvs1) + +addSpecInfo :: SpecInfo -> SpecInfo -> SpecInfo +addSpecInfo (SpecInfo rs1 fvs1) (SpecInfo rs2 fvs2) + = SpecInfo (rs1 ++ rs2) (fvs1 `unionVarSet` fvs2) + +addIdSpecialisations :: Id -> [CoreRule] -> Id +addIdSpecialisations id [] + = id +addIdSpecialisations id rules + = setIdSpecialisation id $ + extendSpecInfo (idSpecialisation id) rules + +-- | Gather all the rules for locally bound identifiers from the supplied bindings +rulesOfBinds :: [CoreBind] -> [CoreRule] +rulesOfBinds binds = concatMap (concatMap idCoreRules . bindersOf) binds + +getRules :: RuleBase -> Id -> [CoreRule] + -- The rules for an Id come from two places: + -- (a) the ones it is born with (idCoreRules fn) + -- (b) rules added in subsequent modules (extra_rules) + -- PrimOps, for example, are born with a bunch of rules under (a) +getRules rule_base fn + | isLocalId fn = idCoreRules fn + | otherwise = WARN( not (isPrimOpId fn) && notNull (idCoreRules fn), + ppr fn <+> ppr (idCoreRules fn) ) + idCoreRules fn ++ (lookupNameEnv rule_base (idName fn) `orElse` []) + -- Only PrimOpIds have rules inside themselves, and perhaps more besides +\end{code} + + +%************************************************************************ +%* * + RuleBase +%* * +%************************************************************************ + +\begin{code} +-- | Gathers a collection of 'CoreRule's. Maps (the name of) an 'Id' to its rules +type RuleBase = NameEnv [CoreRule] + -- The rules are are unordered; + -- we sort out any overlaps on lookup + +emptyRuleBase = emptyNameEnv + +mkRuleBase :: [CoreRule] -> RuleBase +mkRuleBase rules = extendRuleBaseList emptyRuleBase rules + +extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase +extendRuleBaseList rule_base new_guys + = foldl extendRuleBase rule_base new_guys + +unionRuleBase :: RuleBase -> RuleBase -> RuleBase +unionRuleBase rb1 rb2 = plusNameEnv_C (++) rb1 rb2 + +extendRuleBase :: RuleBase -> CoreRule -> RuleBase +extendRuleBase rule_base rule + = extendNameEnv_Acc (:) singleton rule_base (ruleIdName rule) rule + +pprRuleBase :: RuleBase -> SDoc +pprRuleBase rules = vcat [ pprRules (tidyRules emptyTidyEnv rs) + | rs <- nameEnvElts rules ] +\end{code} + + +%************************************************************************ +%* * +\subsection{Matching} +%* * +%************************************************************************ + +Note [Extra args in rule matching] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +If we find a matching rule, we return (Just (rule, rhs)), +but the rule firing has only consumed as many of the input args +as the ruleArity says. It's up to the caller to keep track +of any left-over args. E.g. if you call + lookupRule ... f [e1, e2, e3] +and it returns Just (r, rhs), where r has ruleArity 2 +then the real rewrite is + f e1 e2 e3 ==> rhs e3 + +You might think it'd be cleaner for lookupRule to deal with the +leftover arguments, by applying 'rhs' to them, but the main call +in the Simplifier works better as it is. Reason: the 'args' passed +to lookupRule are the result of a lazy substitution + +\begin{code} +-- | The main rule matching function. Attempts to apply all (active) +-- supplied rules to this instance of an application in a given +-- context, returning the rule applied and the resulting expression if +-- successful. +lookupRule :: (Activation -> Bool) -> InScopeSet + -> Id -> [CoreExpr] + -> [CoreRule] -> Maybe (CoreRule, CoreExpr) + +-- See Note [Extra args in rule matching] +-- See comments on matchRule +lookupRule is_active in_scope fn args rules + = -- pprTrace "matchRules" (ppr fn <+> ppr rules) $ + case go [] rules of + [] -> Nothing + (m:ms) -> Just (findBest (fn,args) m ms) + where + rough_args = map roughTopName args + + go :: [(CoreRule,CoreExpr)] -> [CoreRule] -> [(CoreRule,CoreExpr)] + go ms [] = ms + go ms (r:rs) = case (matchRule is_active in_scope args rough_args r) of + Just e -> go ((r,e):ms) rs + Nothing -> -- pprTrace "match failed" (ppr r $$ ppr args $$ + -- ppr [(arg_id, unfoldingTemplate unf) | Var arg_id <- args, let unf = idUnfolding arg_id, isCheapUnfolding unf] ) + go ms rs + +findBest :: (Id, [CoreExpr]) + -> (CoreRule,CoreExpr) -> [(CoreRule,CoreExpr)] -> (CoreRule,CoreExpr) +-- All these pairs matched the expression +-- Return the pair the the most specific rule +-- The (fn,args) is just for overlap reporting + +findBest target (rule,ans) [] = (rule,ans) +findBest target (rule1,ans1) ((rule2,ans2):prs) + | rule1 `isMoreSpecific` rule2 = findBest target (rule1,ans1) prs + | rule2 `isMoreSpecific` rule1 = findBest target (rule2,ans2) prs + | debugIsOn = let pp_rule rule + | opt_PprStyle_Debug = ppr rule + | otherwise = doubleQuotes (ftext (ru_name rule)) + in pprTrace "Rules.findBest: rule overlap (Rule 1 wins)" + (vcat [if opt_PprStyle_Debug then + ptext (sLit "Expression to match:") <+> ppr fn <+> sep (map ppr args) + else empty, + ptext (sLit "Rule 1:") <+> pp_rule rule1, + ptext (sLit "Rule 2:") <+> pp_rule rule2]) $ + findBest target (rule1,ans1) prs + | otherwise = findBest target (rule1,ans1) prs + where + (fn,args) = target + +isMoreSpecific :: CoreRule -> CoreRule -> Bool +isMoreSpecific (BuiltinRule {}) r2 = True +isMoreSpecific r1 (BuiltinRule {}) = False +isMoreSpecific (Rule { ru_bndrs = bndrs1, ru_args = args1 }) + (Rule { ru_bndrs = bndrs2, ru_args = args2 }) + = isJust (matchN in_scope bndrs2 args2 args1) + where + in_scope = mkInScopeSet (mkVarSet bndrs1) + -- Actually we should probably include the free vars + -- of rule1's args, but I can't be bothered + +noBlackList :: Activation -> Bool +noBlackList act = False -- Nothing is black listed + +matchRule :: (Activation -> Bool) -> InScopeSet + -> [CoreExpr] -> [Maybe Name] + -> CoreRule -> Maybe CoreExpr + +-- If (matchRule rule args) returns Just (name,rhs) +-- then (f args) matches the rule, and the corresponding +-- rewritten RHS is rhs +-- +-- The bndrs and rhs is occurrence-analysed +-- +-- Example +-- +-- The rule +-- forall f g x. map f (map g x) ==> map (f . g) x +-- is stored +-- CoreRule "map/map" +-- [f,g,x] -- tpl_vars +-- [f,map g x] -- tpl_args +-- map (f.g) x) -- rhs +-- +-- Then the call: matchRule the_rule [e1,map e2 e3] +-- = Just ("map/map", (\f,g,x -> rhs) e1 e2 e3) +-- +-- Any 'surplus' arguments in the input are simply put on the end +-- of the output. + +matchRule is_active in_scope args rough_args + (BuiltinRule { ru_name = name, ru_try = match_fn }) + = case match_fn args of + Just expr -> Just expr + Nothing -> Nothing + +matchRule is_active in_scope args rough_args + (Rule { ru_name = rn, ru_act = act, ru_rough = tpl_tops, + ru_bndrs = tpl_vars, ru_args = tpl_args, + ru_rhs = rhs }) + | not (is_active act) = Nothing + | ruleCantMatch tpl_tops rough_args = Nothing + | otherwise + = case matchN in_scope tpl_vars tpl_args args of + Nothing -> Nothing + Just (binds, tpl_vals) -> Just (mkLets binds $ + rule_fn `mkApps` tpl_vals) + where + rule_fn = occurAnalyseExpr (mkLams tpl_vars rhs) + -- We could do this when putting things into the rulebase, I guess +\end{code} + +\begin{code} +-- For a given match template and context, find bindings to wrap around +-- the entire result and what should be substituted for each template variable. +-- Fail if there are two few actual arguments from the target to match the template +matchN :: InScopeSet -- ^ In-scope variables + -> [Var] -- ^ Match template type variables + -> [CoreExpr] -- ^ Match template + -> [CoreExpr] -- ^ Target; can have more elements than the template + -> Maybe ([CoreBind], + [CoreExpr]) + +matchN in_scope tmpl_vars tmpl_es target_es + = do { (tv_subst, id_subst, binds) + <- go init_menv emptySubstEnv tmpl_es target_es + ; return (fromOL binds, + map (lookup_tmpl tv_subst id_subst) tmpl_vars') } + where + (init_rn_env, tmpl_vars') = mapAccumL rnBndrL (mkRnEnv2 in_scope) tmpl_vars + -- See Note [Template binders] + + init_menv = ME { me_tmpls = mkVarSet tmpl_vars', me_env = init_rn_env } + + go menv subst [] es = Just subst + go menv subst ts [] = Nothing -- Fail if too few actual args + go menv subst (t:ts) (e:es) = do { subst1 <- match menv subst t e + ; go menv subst1 ts es } + + lookup_tmpl :: TvSubstEnv -> IdSubstEnv -> Var -> CoreExpr + lookup_tmpl tv_subst id_subst tmpl_var' + | isTyVar tmpl_var' = case lookupVarEnv tv_subst tmpl_var' of + Just ty -> Type ty + Nothing -> unbound tmpl_var' + | otherwise = case lookupVarEnv id_subst tmpl_var' of + Just e -> e + other -> unbound tmpl_var' + + unbound var = pprPanic "Template variable unbound in rewrite rule" + (ppr var $$ ppr tmpl_vars $$ ppr tmpl_vars' $$ ppr tmpl_es $$ ppr target_es) +\end{code} + +Note [Template binders] +~~~~~~~~~~~~~~~~~~~~~~~ +Consider the following match: + Template: forall x. f x + Target: f (x+1) +This should succeed, because the template variable 'x' has +nothing to do with the 'x' in the target. + +On reflection, this case probably does just work, but this might not + Template: forall x. f (\x.x) + Target: f (\y.y) +Here we want to clone when we find the \x, but to know that x must be in scope + +To achive this, we use rnBndrL to rename the template variables if +necessary; the renamed ones are the tmpl_vars' + + + --------------------------------------------- + The inner workings of matching + --------------------------------------------- + +\begin{code} +-- These two definitions are not the same as in Subst, +-- but they simple and direct, and purely local to this module +-- +-- * The domain of the TvSubstEnv and IdSubstEnv are the template +-- variables passed into the match. +-- +-- * The (OrdList CoreBind) in a SubstEnv are the bindings floated out +-- from nested matches; see the Let case of match, below +-- +type SubstEnv = (TvSubstEnv, IdSubstEnv, OrdList CoreBind) +type IdSubstEnv = IdEnv CoreExpr + +emptySubstEnv :: SubstEnv +emptySubstEnv = (emptyVarEnv, emptyVarEnv, nilOL) + + +-- At one stage I tried to match even if there are more +-- template args than real args. + +-- I now think this is probably a bad idea. +-- Should the template (map f xs) match (map g)? I think not. +-- For a start, in general eta expansion wastes work. +-- SLPJ July 99 + + +match :: MatchEnv + -> SubstEnv + -> CoreExpr -- Template + -> CoreExpr -- Target + -> Maybe SubstEnv + +-- See the notes with Unify.match, which matches types +-- Everything is very similar for terms + +-- Interesting examples: +-- Consider matching +-- \x->f against \f->f +-- When we meet the lambdas we must remember to rename f to f' in the +-- second expresion. The RnEnv2 does that. +-- +-- Consider matching +-- forall a. \b->b against \a->3 +-- We must rename the \a. Otherwise when we meet the lambdas we +-- might substitute [a/b] in the template, and then erroneously +-- succeed in matching what looks like the template variable 'a' against 3. + +-- The Var case follows closely what happens in Unify.match +match menv subst (Var v1) e2 + | Just subst <- match_var menv subst v1 e2 + = Just subst + +match menv subst e1 (Note n e2) + = match menv subst e1 e2 + -- Note [Notes in RULE matching] + -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + -- Look through Notes. In particular, we don't want to + -- be confused by InlineMe notes. Maybe we should be more + -- careful about profiling notes, but for now I'm just + -- riding roughshod over them. + --- See Note [Notes in call patterns] in SpecConstr + +-- Here is another important rule: if the term being matched is a +-- variable, we expand it so long as its unfolding is a WHNF +-- (Its occurrence information is not necessarily up to date, +-- so we don't use it.) +match menv subst e1 (Var v2) + | isCheapUnfolding unfolding + = match menv subst e1 (unfoldingTemplate unfolding) + where + rn_env = me_env menv + unfolding = idUnfolding (lookupRnInScope rn_env (rnOccR rn_env v2)) + -- Notice that we look up v2 in the in-scope set + -- See Note [Lookup in-scope] + -- Remember to apply any renaming first (hence rnOccR) + +-- Note [Matching lets] +-- ~~~~~~~~~~~~~~~~~~~~ +-- Matching a let-expression. Consider +-- RULE forall x. f (g x) = +-- and target expression +-- f (let { w=R } in g E)) +-- Then we'd like the rule to match, to generate +-- let { w=R } in (\x. ) E +-- In effect, we want to float the let-binding outward, to enable +-- the match to happen. This is the WHOLE REASON for accumulating +-- bindings in the SubstEnv +-- +-- We can only do this if +-- (a) Widening the scope of w does not capture any variables +-- We use a conservative test: w is not already in scope +-- If not, we clone the binders, and substitute +-- (b) The free variables of R are not bound by the part of the +-- target expression outside the let binding; e.g. +-- f (\v. let w = v+1 in g E) +-- Here we obviously cannot float the let-binding for w. +-- +-- You may think rule (a) would never apply, because rule matching is +-- mostly invoked from the simplifier, when we have just run substExpr +-- over the argument, so there will be no shadowing anyway. +-- The fly in the ointment is that the forall'd variables of the +-- RULE itself are considered in scope. +-- +-- I though of various cheapo ways to solve this tiresome problem, +-- but ended up doing the straightforward thing, which is to +-- clone the binders if they are in scope. It's tiresome, and +-- potentially inefficient, because of the calls to substExpr, +-- but I don't think it'll happen much in pracice. + +{- Cases to think about + (let x=y+1 in \x. (x,x)) + --> let x=y+1 in (\x1. (x1,x1)) + (\x. let x = y+1 in (x,x)) + --> let x1 = y+1 in (\x. (x1,x1) + (let x=y+1 in (x,x), let x=y-1 in (x,x)) + --> let x=y+1 in let x1=y-1 in ((x,x),(x1,x1)) + +Watch out! + (let x=y+1 in let z=x+1 in (z,z) + --> matches (p,p) but watch out that the use of + x on z's rhs is OK! +I'm removing the cloning because that makes the above case +fail, because the inner let looks as if it has locally-bound vars -} + +match menv subst@(tv_subst, id_subst, binds) e1 (Let bind e2) + | all freshly_bound bndrs, + not (any locally_bound bind_fvs) + = match (menv { me_env = rn_env' }) + (tv_subst, id_subst, binds `snocOL` bind') + e1 e2' + where + rn_env = me_env menv + bndrs = bindersOf bind + bind_fvs = varSetElems (bindFreeVars bind) + locally_bound x = inRnEnvR rn_env x + freshly_bound x = not (x `rnInScope` rn_env) + bind' = bind + e2' = e2 + rn_env' = extendRnInScopeList rn_env bndrs +{- + (rn_env', bndrs') = mapAccumL rnBndrR rn_env bndrs + s_prs = [(bndr, Var bndr') | (bndr,bndr') <- zip bndrs bndrs', bndr /= bndr'] + subst = mkSubst (rnInScopeSet rn_env) emptyVarEnv (mkVarEnv s_prs) + (bind', e2') | null s_prs = (bind, e2) + | otherwise = (s_bind, substExpr subst e2) + s_bind = case bind of + NonRec {} -> NonRec (head bndrs') (head rhss) + Rec {} -> Rec (bndrs' `zip` map (substExpr subst) rhss) +-} + +match menv subst (Lit lit1) (Lit lit2) + | lit1 == lit2 + = Just subst + +match menv subst (App f1 a1) (App f2 a2) + = do { subst' <- match menv subst f1 f2 + ; match menv subst' a1 a2 } + +match menv subst (Lam x1 e1) (Lam x2 e2) + = match menv' subst e1 e2 + where + menv' = menv { me_env = rnBndr2 (me_env menv) x1 x2 } + +-- This rule does eta expansion +-- (\x.M) ~ N iff M ~ N x +-- It's important that this is *after* the let rule, +-- so that (\x.M) ~ (let y = e in \y.N) +-- does the let thing, and then gets the lam/lam rule above +match menv subst (Lam x1 e1) e2 + = match menv' subst e1 (App e2 (varToCoreExpr new_x)) + where + (rn_env', new_x) = rnBndrL (me_env menv) x1 + menv' = menv { me_env = rn_env' } + +-- Eta expansion the other way +-- M ~ (\y.N) iff M y ~ N +match menv subst e1 (Lam x2 e2) + = match menv' subst (App e1 (varToCoreExpr new_x)) e2 + where + (rn_env', new_x) = rnBndrR (me_env menv) x2 + menv' = menv { me_env = rn_env' } + +match menv subst (Case e1 x1 ty1 alts1) (Case e2 x2 ty2 alts2) + = do { subst1 <- match_ty menv subst ty1 ty2 + ; subst2 <- match menv subst1 e1 e2 + ; let menv' = menv { me_env = rnBndr2 (me_env menv) x1 x2 } + ; match_alts menv' subst2 alts1 alts2 -- Alts are both sorted + } + +match menv subst (Type ty1) (Type ty2) + = match_ty menv subst ty1 ty2 + +match menv subst (Cast e1 co1) (Cast e2 co2) + = do { subst1 <- match_ty menv subst co1 co2 + ; match menv subst1 e1 e2 } + +{- REMOVING OLD CODE: I think that the above handling for let is + better than the stuff here, which looks + pretty suspicious to me. SLPJ Sept 06 +-- This is an interesting rule: we simply ignore lets in the +-- term being matched against! The unfolding inside it is (by assumption) +-- already inside any occurrences of the bound variables, so we'll expand +-- them when we encounter them. This gives a chance of matching +-- forall x,y. f (g (x,y)) +-- against +-- f (let v = (a,b) in g v) + +match menv subst e1 (Let bind e2) + = match (menv { me_env = rn_env' }) subst e1 e2 + where + (rn_env', _bndrs') = mapAccumL rnBndrR (me_env menv) (bindersOf bind) + -- It's important to do this renaming, so that the bndrs + -- are brought into the local scope. For example: + -- Matching + -- forall f,x,xs. f (x:xs) + -- against + -- f (let y = e in (y:[])) + -- We must not get success with x->y! So we record that y is + -- locally bound (with rnBndrR), and proceed. The Var case + -- will fail when trying to bind x->y +-} + +-- Everything else fails +match menv subst e1 e2 = -- pprTrace "Failing at" ((text "e1:" <+> ppr e1) $$ (text "e2:" <+> ppr e2)) $ + Nothing + +------------------------------------------ +match_var :: MatchEnv + -> SubstEnv + -> Var -- Template + -> CoreExpr -- Target + -> Maybe SubstEnv +match_var menv subst@(tv_subst, id_subst, binds) v1 e2 + | v1' `elemVarSet` me_tmpls menv + = case lookupVarEnv id_subst v1' of + Nothing | any (inRnEnvR rn_env) (varSetElems (exprFreeVars e2)) + -> Nothing -- Occurs check failure + -- e.g. match forall a. (\x-> a x) against (\y. y y) + + | otherwise -- No renaming to do on e2, because no free var + -- of e2 is in the rnEnvR of the envt + -- Note [Matching variable types] + -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + -- However, we must match the *types*; e.g. + -- forall (c::Char->Int) (x::Char). + -- f (c x) = "RULE FIRED" + -- We must only match on args that have the right type + -- It's actually quite difficult to come up with an example that shows + -- you need type matching, esp since matching is left-to-right, so type + -- args get matched first. But it's possible (e.g. simplrun008) and + -- this is the Right Thing to do + -> do { tv_subst' <- Unify.ruleMatchTyX menv tv_subst (idType v1') (exprType e2) + -- c.f. match_ty below + ; return (tv_subst', extendVarEnv id_subst v1' e2, binds) } + + Just e1' | tcEqExprX (nukeRnEnvL rn_env) e1' e2 + -> Just subst + + | otherwise + -> Nothing + + | otherwise -- v1 is not a template variable; check for an exact match with e2 + = case e2 of + Var v2 | v1' == rnOccR rn_env v2 -> Just subst + other -> Nothing + + where + rn_env = me_env menv + v1' = rnOccL rn_env v1 + -- If the template is + -- forall x. f x (\x -> x) = ... + -- Then the x inside the lambda isn't the + -- template x, so we must rename first! + + +------------------------------------------ +match_alts :: MatchEnv + -> SubstEnv + -> [CoreAlt] -- Template + -> [CoreAlt] -- Target + -> Maybe SubstEnv +match_alts menv subst [] [] + = return subst +match_alts menv subst ((c1,vs1,r1):alts1) ((c2,vs2,r2):alts2) + | c1 == c2 + = do { subst1 <- match menv' subst r1 r2 + ; match_alts menv subst1 alts1 alts2 } + where + menv' :: MatchEnv + menv' = menv { me_env = rnBndrs2 (me_env menv) vs1 vs2 } + +match_alts menv subst alts1 alts2 + = Nothing +\end{code} + +Matching Core types: use the matcher in TcType. +Notice that we treat newtypes as opaque. For example, suppose +we have a specialised version of a function at a newtype, say + newtype T = MkT Int +We only want to replace (f T) with f', not (f Int). + +\begin{code} +------------------------------------------ +match_ty :: MatchEnv + -> SubstEnv + -> Type -- Template + -> Type -- Target + -> Maybe SubstEnv +match_ty menv (tv_subst, id_subst, binds) ty1 ty2 + = do { tv_subst' <- Unify.ruleMatchTyX menv tv_subst ty1 ty2 + ; return (tv_subst', id_subst, binds) } +\end{code} + + +Note [Lookup in-scope] +~~~~~~~~~~~~~~~~~~~~~~ +Consider this example + foo :: Int -> Maybe Int -> Int + foo 0 (Just n) = n + foo m (Just n) = foo (m-n) (Just n) + +SpecConstr sees this fragment: + + case w_smT of wild_Xf [Just A] { + Data.Maybe.Nothing -> lvl_smf; + Data.Maybe.Just n_acT [Just S(L)] -> + case n_acT of wild1_ams [Just A] { GHC.Base.I# y_amr [Just L] -> + \$wfoo_smW (GHC.Prim.-# ds_Xmb y_amr) wild_Xf + }}; + +and correctly generates the rule + + RULES: "SC:$wfoo1" [0] __forall {y_amr [Just L] :: GHC.Prim.Int# + sc_snn :: GHC.Prim.Int#} + \$wfoo_smW sc_snn (Data.Maybe.Just @ GHC.Base.Int (GHC.Base.I# y_amr)) + = \$s\$wfoo_sno y_amr sc_snn ;] + +BUT we must ensure that this rule matches in the original function! +Note that the call to \$wfoo is + \$wfoo_smW (GHC.Prim.-# ds_Xmb y_amr) wild_Xf + +During matching we expand wild_Xf to (Just n_acT). But then we must also +expand n_acT to (I# y_amr). And we can only do that if we look up n_acT +in the in-scope set, because in wild_Xf's unfolding it won't have an unfolding +at all. + +That is why the 'lookupRnInScope' call in the (Var v2) case of 'match' +is so important. + + +%************************************************************************ +%* * +\subsection{Checking a program for failing rule applications} +%* * +%************************************************************************ + +----------------------------------------------------- + Game plan +----------------------------------------------------- + +We want to know what sites have rules that could have fired but didn't. +This pass runs over the tree (without changing it) and reports such. + +\begin{code} +-- | Report partial matches for rules beginning with the specified +-- string for the purposes of error reporting +ruleCheckProgram :: (Activation -> Bool) -- ^ Rule activation test + -> String -- ^ Rule pattern + -> RuleBase -- ^ Database of rules + -> [CoreBind] -- ^ Bindings to check in + -> SDoc -- ^ Resulting check message +ruleCheckProgram is_active rule_pat rule_base binds + | isEmptyBag results + = text "Rule check results: no rule application sites" + | otherwise + = vcat [text "Rule check results:", + line, + vcat [ p $$ line | p <- bagToList results ] + ] + where + results = unionManyBags (map (ruleCheckBind (RuleCheckEnv is_active rule_pat rule_base)) binds) + line = text (replicate 20 '-') + +data RuleCheckEnv = RuleCheckEnv { + rc_is_active :: Activation -> Bool, + rc_pattern :: String, + rc_rule_base :: RuleBase +} + +ruleCheckBind :: RuleCheckEnv -> CoreBind -> Bag SDoc + -- The Bag returned has one SDoc for each call site found +ruleCheckBind env (NonRec b r) = ruleCheck env r +ruleCheckBind env (Rec prs) = unionManyBags [ruleCheck env r | (b,r) <- prs] + +ruleCheck :: RuleCheckEnv -> CoreExpr -> Bag SDoc +ruleCheck env (Var v) = emptyBag +ruleCheck env (Lit l) = emptyBag +ruleCheck env (Type ty) = emptyBag +ruleCheck env (App f a) = ruleCheckApp env (App f a) [] +ruleCheck env (Note n e) = ruleCheck env e +ruleCheck env (Cast e co) = ruleCheck env e +ruleCheck env (Let bd e) = ruleCheckBind env bd `unionBags` ruleCheck env e +ruleCheck env (Lam b e) = ruleCheck env e +ruleCheck env (Case e _ _ as) = ruleCheck env e `unionBags` + unionManyBags [ruleCheck env r | (_,_,r) <- as] + +ruleCheckApp env (App f a) as = ruleCheck env a `unionBags` ruleCheckApp env f (a:as) +ruleCheckApp env (Var f) as = ruleCheckFun env f as +ruleCheckApp env other as = ruleCheck env other +\end{code} + +\begin{code} +ruleCheckFun :: RuleCheckEnv -> Id -> [CoreExpr] -> Bag SDoc +-- Produce a report for all rules matching the predicate +-- saying why it doesn't match the specified application + +ruleCheckFun env fn args + | null name_match_rules = emptyBag + | otherwise = unitBag (ruleAppCheck_help (rc_is_active env) fn args name_match_rules) + where + name_match_rules = filter match (getRules (rc_rule_base env) fn) + match rule = (rc_pattern env) `isPrefixOf` unpackFS (ruleName rule) + +ruleAppCheck_help :: (Activation -> Bool) -> Id -> [CoreExpr] -> [CoreRule] -> SDoc +ruleAppCheck_help is_active fn args rules + = -- The rules match the pattern, so we want to print something + vcat [text "Expression:" <+> ppr (mkApps (Var fn) args), + vcat (map check_rule rules)] + where + n_args = length args + i_args = args `zip` [1::Int ..] + rough_args = map roughTopName args + + check_rule rule = rule_herald rule <> colon <+> rule_info rule + + rule_herald (BuiltinRule { ru_name = name }) + = ptext (sLit "Builtin rule") <+> doubleQuotes (ftext name) + rule_herald (Rule { ru_name = name }) + = ptext (sLit "Rule") <+> doubleQuotes (ftext name) + + rule_info rule + | Just _ <- matchRule noBlackList emptyInScopeSet args rough_args rule + = text "matches (which is very peculiar!)" + + rule_info (BuiltinRule {}) = text "does not match" + + rule_info (Rule { ru_name = name, ru_act = act, + ru_bndrs = rule_bndrs, ru_args = rule_args}) + | not (is_active act) = text "active only in later phase" + | n_args < n_rule_args = text "too few arguments" + | n_mismatches == n_rule_args = text "no arguments match" + | n_mismatches == 0 = text "all arguments match (considered individually), but rule as a whole does not" + | otherwise = text "arguments" <+> ppr mismatches <+> text "do not match (1-indexing)" + where + n_rule_args = length rule_args + n_mismatches = length mismatches + mismatches = [i | (rule_arg, (arg,i)) <- rule_args `zip` i_args, + not (isJust (match_fn rule_arg arg))] + + lhs_fvs = exprsFreeVars rule_args -- Includes template tyvars + match_fn rule_arg arg = match menv emptySubstEnv rule_arg arg + where + in_scope = lhs_fvs `unionVarSet` exprFreeVars arg + menv = ME { me_env = mkRnEnv2 (mkInScopeSet in_scope) + , me_tmpls = mkVarSet rule_bndrs } +\end{code} + diff --git a/Test/examples/RealHSE.hs b/Test/examples/RealHSE.hs new file mode 100644 --- /dev/null +++ b/Test/examples/RealHSE.hs @@ -0,0 +1,898 @@ +-- #hide +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.Lexer +-- Copyright : (c) The GHC Team, 1997-2000 +-- (c) Niklas Broberg, 2004 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +-- Stability : experimental +-- Portability : portable +-- +-- Lexer for Haskell, with some extensions. +-- +----------------------------------------------------------------------------- + +-- ToDo: Introduce different tokens for decimal, octal and hexadecimal (?) +-- ToDo: FloatTok should have three parts (integer part, fraction, exponent) (?) +-- ToDo: Use a lexical analyser generator (lx?) + +module Language.Haskell.Exts.Lexer (Token(..), lexer) where + +import Language.Haskell.Exts.ParseMonad + +import Data.Char +import Data.Ratio + +data Token + = VarId String + | QVarId (String,String) + | IDupVarId (String) -- duplicable implicit parameter + | ILinVarId (String) -- linear implicit parameter + | ConId String + | QConId (String,String) + | DVarId [String] -- to enable varid's with '-' in them + | VarSym String + | ConSym String + | QVarSym (String,String) + | QConSym (String,String) + | IntTok Integer + | FloatTok Rational + | Character Char + | StringTok String + +-- Symbols + + | LeftParen + | RightParen + | LeftHashParen + | RightHashParen + | SemiColon + | LeftCurly + | RightCurly + | VRightCurly -- a virtual close brace + | LeftSquare + | RightSquare + | Comma + | Underscore + | BackQuote + +-- Reserved operators + + | Dot -- reserved for use with 'forall x . x' + | DotDot + | Colon + | DoubleColon + | Equals + | Backslash + | Bar + | LeftArrow + | RightArrow + | At + | Tilde + | DoubleArrow + | Minus + | Exclamation + | Star + +-- Template Haskell + | THExpQuote -- [| or [e| + | THPatQuote -- [p| + | THDecQuote -- [d| + | THTypQuote -- [t| + | THCloseQuote -- |] + | THIdEscape (String) -- dollar x + | THParenEscape -- dollar ( + | THVarQuote -- 'x (but without the x) + | THTyQuote -- ''T (but without the T) + +-- HaRP + | RPGuardOpen -- (| + | RPGuardClose -- |) + | RPCAt -- @: + +-- Hsx + | XCodeTagOpen -- <% + | XCodeTagClose -- %> + | XStdTagOpen -- < + | XStdTagClose -- > + | XCloseTagOpen -- + | XPCDATA String + | XRPatOpen -- <[ + | XRPatClose -- ]> + +-- Pragmas + + | PragmaEnd -- #-} + | PragmaUnknown (String,String) -- Any pragma not recognized + | RULES + | INLINE Bool + | SPECIALISE + | SPECIALISE_INLINE Bool + | SOURCE + | DEPRECATED + | WARNING + | SCC + | GENERATED + | CORE + | UNPACK + | OPTIONS (Maybe String,String) + | CFILES String + | LANGUAGE + | INCLUDE String +-- These are not yet implemented +-- | LINE + +-- Reserved Ids + + | KW_As + | KW_Case + | KW_Class + | KW_Data + | KW_Default + | KW_Deriving + | KW_Do + | KW_MDo + | KW_Else + | KW_Family -- indexed type families + | KW_Forall -- universal/existential types + | KW_Hiding + | KW_If + | KW_Import + | KW_In + | KW_Infix + | KW_InfixL + | KW_InfixR + | KW_Instance + | KW_Let + | KW_Module + | KW_NewType + | KW_Of + | KW_Then + | KW_Type + | KW_Where + | KW_Qualified + + -- FFI + | KW_Foreign + | KW_Export + | KW_Safe + | KW_Unsafe + | KW_Threadsafe + | KW_StdCall + | KW_CCall + + | EOF + deriving (Eq,Show) + +reserved_ops :: [(String,Token)] +reserved_ops = [ + ( ".", Dot ), + ( "..", DotDot ), + ( ":", Colon ), + ( "::", DoubleColon ), + ( "=", Equals ), + ( "\\", Backslash ), + ( "|", Bar ), + ( "<-", LeftArrow ), + ( "->", RightArrow ), + ( "@", At ), + ( "~", Tilde ), + ( "=>", DoubleArrow ), + ( "*", Star ) + ] + +special_varops :: [(String,Token)] +special_varops = [ + ( "-", Minus ), --ToDo: shouldn't be here + ( "!", Exclamation ) --ditto + ] + +reserved_ids :: [(String,Token)] +reserved_ids = [ + ( "_", Underscore ), + ( "case", KW_Case ), + ( "class", KW_Class ), + ( "data", KW_Data ), + ( "default", KW_Default ), + ( "deriving", KW_Deriving ), + ( "do", KW_Do ), + ( "else", KW_Else ), + ( "family", KW_Family ), -- indexed type families + ( "forall", KW_Forall ), -- universal/existential quantification + ( "if", KW_If ), + ( "import", KW_Import ), + ( "in", KW_In ), + ( "infix", KW_Infix ), + ( "infixl", KW_InfixL ), + ( "infixr", KW_InfixR ), + ( "instance", KW_Instance ), + ( "let", KW_Let ), + ( "mdo", KW_MDo ), + ( "module", KW_Module ), + ( "newtype", KW_NewType ), + ( "of", KW_Of ), + ( "then", KW_Then ), + ( "type", KW_Type ), + ( "where", KW_Where ), + +-- FFI + ( "foreign", KW_Foreign ) + ] + + +special_varids :: [(String,Token)] +special_varids = [ + ( "as", KW_As ), + ( "qualified", KW_Qualified ), + ( "hiding", KW_Hiding ), + +-- FFI + ( "export", KW_Export), + ( "safe", KW_Safe), + ( "unsafe", KW_Unsafe), + ( "threadsafe", KW_Threadsafe), + ( "stdcall", KW_StdCall), + ( "ccall", KW_CCall) + ] + +pragmas :: [(String,Token)] +pragmas = [ + ( "rules", RULES ), + ( "inline", INLINE True ), + ( "noinline", INLINE False ), + ( "notinline", INLINE False ), + ( "specialise", SPECIALISE ), + ( "specialize", SPECIALISE ), + ( "source", SOURCE ), + ( "deprecated", DEPRECATED ), + ( "warning", WARNING ), + ( "scc", SCC ), + ( "generated", GENERATED ), + ( "core", CORE ), + ( "unpack", UNPACK ), + ( "language", LANGUAGE ), + ( "options", OPTIONS undefined ), -- we'll tweak it before use - promise! + ( "cfiles", CFILES undefined ), -- same here... + ( "include", INCLUDE undefined ) -- ...and here! + ] + +isIdent, isHSymbol :: Char -> Bool +isIdent c = isAlpha c || isDigit c || c == '\'' || c == '_' + +isHSymbol c = c `elem` ":!#%&*./?@\\-" || ((isSymbol c || isPunctuation c) && not (c `elem` "(),;[]`{}_\"'")) + +matchChar :: Char -> String -> Lex a () +matchChar c msg = do + s <- getInput + if null s || head s /= c then fail msg else discard 1 + +-- The top-level lexer. +-- We need to know whether we are at the beginning of the line to decide +-- whether to insert layout tokens. + +lexer :: (Token -> P a) -> P a +lexer = runL $ do + bol <- checkBOL + (bol, ws) <- lexWhiteSpace bol + -- take care of whitespace in PCDATA + ec <- getExtContext + case ec of + -- if there was no linebreak, and we are lexing PCDATA, + -- then we want to care about the whitespace + Just ChildCtxt | not bol && ws -> return $ XPCDATA " " + _ -> do startToken + if bol then lexBOL else lexToken + +lexWhiteSpace :: Bool -> Lex a (Bool, Bool) +lexWhiteSpace bol = do + s <- getInput + case s of + '{':'-':'#':_ -> do + return (bol, False) + '{':'-':_ -> do + discard 2 + bol <- lexNestedComment bol + (bol, _) <- lexWhiteSpace bol + return (bol, True) + '-':'-':s | all (== '-') (takeWhile isHSymbol s) -> do + lexWhile (== '-') + lexWhile (/= '\n') + s' <- getInput + case s' of + [] -> fail "Unterminated end-of-line comment" + _ -> do + lexNewline + lexWhiteSpace True + return (True, True) + '\n':_ -> do + lexNewline + lexWhiteSpace True + return (True, True) + '\t':_ -> do + lexTab + (bol, _) <- lexWhiteSpace bol + return (bol, True) + c:_ | isSpace c -> do + discard 1 + (bol, _) <- lexWhiteSpace bol + return (bol, True) + _ -> return (bol, False) + +lexNestedComment :: Bool -> Lex a Bool +lexNestedComment bol = do + s <- getInput + case s of + '-':'}':_ -> discard 2 >> return bol + '{':'-':_ -> do + discard 2 + bol <- lexNestedComment bol -- rest of the subcomment + lexNestedComment bol -- rest of this comment + '\t':_ -> lexTab >> lexNestedComment bol + '\n':_ -> lexNewline >> lexNestedComment True + _:_ -> discard 1 >> lexNestedComment bol + [] -> fail "Unterminated nested comment" + +-- When we are lexing the first token of a line, check whether we need to +-- insert virtual semicolons or close braces due to layout. + +lexBOL :: Lex a Token +lexBOL = do + pos <- getOffside + case pos of + LT -> do + -- trace "layout: inserting '}'\n" $ + -- Set col to 0, indicating that we're still at the + -- beginning of the line, in case we need a semi-colon too. + -- Also pop the context here, so that we don't insert + -- another close brace before the parser can pop it. + setBOL + popContextL "lexBOL" + return VRightCurly + EQ -> + -- trace "layout: inserting ';'\n" $ + return SemiColon + GT -> lexToken + +lexToken :: Lex a Token +lexToken = do + ec <- getExtContext + case ec of + Just HarpCtxt -> lexHarpToken + Just TagCtxt -> lexTagCtxt + Just CloseTagCtxt -> lexCloseTagCtxt + Just ChildCtxt -> lexChildCtxt + Just CodeTagCtxt -> lexCodeTagCtxt + _ -> lexStdToken + + +lexChildCtxt :: Lex a Token +lexChildCtxt = do + s <- getInput + case s of + '<':'%':_ -> do discard 2 + pushExtContextL CodeTagCtxt + return XCodeTagOpen + '<':'/':_ -> do discard 2 + popExtContextL "lexChildCtxt" + pushExtContextL CloseTagCtxt + return XCloseTagOpen + '<':'[':_ -> do discard 2 + pushExtContextL HarpCtxt + return XRPatOpen + '<':_ -> do discard 1 + pushExtContextL TagCtxt + return XStdTagOpen + _ -> lexPCDATA + + +lexPCDATA :: Lex a Token +lexPCDATA = do + s <- getInput + case s of + [] -> return EOF + _ -> case s of + '\n':_ -> do + x <- lexNewline >> lexPCDATA + case x of + XPCDATA p -> return $ XPCDATA $ '\n':p + EOF -> return EOF + '<':_ -> return $ XPCDATA "" + _ -> do let pcd = takeWhile (\c -> not $ elem c "<\n") s + l = length pcd + discard l + x <- lexPCDATA + case x of + XPCDATA pcd' -> return $ XPCDATA $ pcd ++ pcd' + EOF -> return EOF + + +lexCodeTagCtxt :: Lex a Token +lexCodeTagCtxt = do + s <- getInput + case s of + '%':'>':_ -> do discard 2 + popExtContextL "lexCodeTagContext" + return XCodeTagClose + _ -> lexStdToken + +lexCloseTagCtxt :: Lex a Token +lexCloseTagCtxt = do + s <- getInput + case s of + '>':_ -> do discard 1 + popExtContextL "lexCloseTagCtxt" + return XStdTagClose + _ -> lexStdToken + +lexTagCtxt :: Lex a Token +lexTagCtxt = do + s <- getInput + case s of + '/':'>':_ -> do discard 2 + popExtContextL "lexTagCtxt: Empty tag" + return XEmptyTagClose + '>':_ -> do discard 1 + popExtContextL "lexTagCtxt: Standard tag" + pushExtContextL ChildCtxt + return XStdTagClose + _ -> lexStdToken + +lexHarpToken :: Lex a Token +lexHarpToken = do + s <- getInput + case s of + ']':'>':_ -> do discard 2 + popExtContextL "lexHarpToken" + return XRPatClose + _ -> lexStdToken + +lexStdToken :: Lex a Token +lexStdToken = do + s <- getInput + case s of + [] -> return EOF + + '0':c:d:_ | toLower c == 'o' && isOctDigit d -> do + discard 2 + n <- lexOctal + return (IntTok n) + | toLower c == 'x' && isHexDigit d -> do + discard 2 + n <- lexHexadecimal + return (IntTok n) + + -- implicit parameters + '?':c:_ | isLower c -> do + discard 1 + id <- lexWhile isIdent + return $ IDupVarId id + + '%':c:_ | isLower c -> do + discard 1 + id <- lexWhile isIdent + return $ ILinVarId id + -- end implicit parameters + + -- harp + '(':'|':c:_ | isHSymbol c -> discard 1 >> return LeftParen + '(':'|':_ -> do discard 2 + return RPGuardOpen + '|':')':_ -> do discard 2 + return RPGuardClose + '@':':':_ -> do discard 2 + return RPCAt + + -- template haskell + '[':'|':_ -> do + discard 2 + return $ THExpQuote + + '[':c:'|':_ | c == 'e' -> do + discard 3 + return $ THExpQuote + | c == 'p' -> do + discard 3 + return THPatQuote + | c == 'd' -> do + discard 3 + return THDecQuote + | c == 't' -> do + discard 3 + return THTypQuote + + '|':']':_ -> do discard 2 + return THCloseQuote + + '$':c:_ | isLower c -> do + discard 1 + id <- lexWhile isIdent + return $ THIdEscape id + | c == '(' -> do + discard 2 + return THParenEscape + -- end template haskell + + -- hsx + '<':'%':_ -> do discard 2 + pushExtContextL CodeTagCtxt + return XCodeTagOpen + '<':c:_ | isAlpha c -> do discard 1 + pushExtContextL TagCtxt + return XStdTagOpen + -- end hsx + + '(':'#':_ -> do discard 2 >> return LeftHashParen + + '#':')':_ -> do discard 2 >> return RightHashParen + + -- pragmas + + '{':'-':'#':_ -> do discard 3 >> lexPragmaStart + + '#':'-':'}':_ -> do discard 3 >> return PragmaEnd + + c:_ | isDigit c -> lexDecimalOrFloat + + | isUpper c -> lexConIdOrQual "" + + | isLower c || c == '_' -> do + idents <- lexIdents + case idents of + [ident] -> return $ case lookup ident (reserved_ids ++ special_varids) of + Just keyword -> keyword + Nothing -> VarId ident + _ -> return $ DVarId idents + + | isHSymbol c -> do + sym <- lexWhile isHSymbol + return $ case lookup sym (reserved_ops ++ special_varops) of + Just t -> t + Nothing -> case c of + ':' -> ConSym sym + _ -> VarSym sym + + | otherwise -> do + discard 1 + case c of + + -- First the special symbols + '(' -> return LeftParen + ')' -> return RightParen + ',' -> return Comma + ';' -> return SemiColon + '[' -> return LeftSquare + ']' -> return RightSquare + '`' -> return BackQuote + '{' -> do + pushContextL NoLayout + return LeftCurly + '}' -> do + popContextL "lexStdToken" + return RightCurly + + '\'' -> lexCharacter + '"' -> lexString + + _ -> fail ("Illegal character \'" ++ show c ++ "\'\n") + + where lexIdents :: Lex a [String] + lexIdents = do + ident <- lexWhile isIdent + s <- getInput + case s of + '-':c:_ | isAlpha c -> do + discard 1 + idents <- lexIdents + return $ ident : idents + '#':_ -> do + discard 1 + return [ident ++ "#"] + _ -> return [ident] + + +lexPragmaStart :: Lex a Token +lexPragmaStart = do + lexWhile isSpace + pr <- lexWhile isAlphaNum + case lookup (map toLower pr) pragmas of + Just SPECIALISE -> do + s <- getInput + case dropWhile isSpace $ map toLower s of + 'i':'n':'l':'i':'n':'e':_ -> do + lexWhile isSpace + discard 6 + return $ SPECIALISE_INLINE True + 'n':'o':'i':'n':'l':'i':'n':'e':_ -> do + lexWhile isSpace + discard 8 + return $ SPECIALISE_INLINE False + 'n':'o':'t':'i':'n':'l':'i':'n':'e':_ -> do + lexWhile isSpace + discard 9 + return $ SPECIALISE_INLINE False + _ -> return SPECIALISE + + Just (OPTIONS _) -> do -- see, I promised we'd mask out the 'undefined' + s <- getInput + case s of + '_':_ -> do + discard 1 + com <- lexWhile isIdent + rest <- lexRawPragma + return $ OPTIONS (Just com, rest) + x:_ | isSpace x -> do + rest <- lexRawPragma + return $ OPTIONS (Nothing, rest) + _ -> fail "Malformed Options pragma" + Just (CFILES _) -> do + rest <- lexRawPragma + return $ CFILES rest + Just (INCLUDE _) -> do + rest <- lexRawPragma + return $ INCLUDE rest + Just p -> return p + + _ -> do rawStr <- lexRawPragma + return $ PragmaUnknown (pr, rawStr) + +lexRawPragma :: Lex a String +lexRawPragma = do + rpr <- lexRawPragmaAux + return $ dropWhile isSpace rpr + where lexRawPragmaAux = do + rpr <- lexWhile (/='#') + s <- getInput + case s of + '#':'-':'}':_ -> return rpr + _ -> do + discard 1 + rpr' <- lexRawPragma + return $ rpr ++ '#':rpr' + +lexDecimalOrFloat :: Lex a Token +lexDecimalOrFloat = do + ds <- lexWhile isDigit + rest <- getInput + case rest of + ('.':d:_) | isDigit d -> do + discard 1 + frac <- lexWhile isDigit + let num = parseInteger 10 (ds ++ frac) + decimals = toInteger (length frac) + exponent <- do + rest2 <- getInput + case rest2 of + 'e':_ -> lexExponent + 'E':_ -> lexExponent + _ -> return 0 + return (FloatTok ((num%1) * 10^^(exponent - decimals))) + e:_ | toLower e == 'e' -> do + exponent <- lexExponent + return (FloatTok ((parseInteger 10 ds%1) * 10^^exponent)) + _ -> return (IntTok (parseInteger 10 ds)) + + where + lexExponent :: Lex a Integer + lexExponent = do + discard 1 -- 'e' or 'E' + r <- getInput + case r of + '+':d:_ | isDigit d -> do + discard 1 + lexDecimal + '-':d:_ | isDigit d -> do + discard 1 + n <- lexDecimal + return (negate n) + d:_ | isDigit d -> lexDecimal + _ -> fail "Float with missing exponent" + +lexConIdOrQual :: String -> Lex a Token +lexConIdOrQual qual = do + con <- lexWhile isIdent + let conid | null qual = ConId con + | otherwise = QConId (qual,con) + qual' | null qual = con + | otherwise = qual ++ '.':con + just_a_conid <- alternative (return conid) + rest <- getInput + case rest of + '.':c:_ + | isLower c || c == '_' -> do -- qualified varid? + discard 1 + ident <- lexWhile isIdent + s <- getInput + ident' <- case s of + '#':_ -> discard 1 >> return (ident ++ "#") + _ -> return ident + case lookup ident' reserved_ids of + -- cannot qualify a reserved word + Just _ -> just_a_conid + Nothing -> return (QVarId (qual', ident')) + + | isUpper c -> do -- qualified conid? + discard 1 + lexConIdOrQual qual' + + | isHSymbol c -> do -- qualified symbol? + discard 1 + sym <- lexWhile isHSymbol + case lookup sym reserved_ops of + -- cannot qualify a reserved operator + Just _ -> just_a_conid + Nothing -> return $ case c of + ':' -> QConSym (qual', sym) + _ -> QVarSym (qual', sym) + + '#':c:_ + | isSpace c -> do + discard 1 + case conid of + ConId con -> return $ ConId $ con ++ "#" + QConId (q,con) -> return $ QConId (q,con ++ "#") + _ -> return conid -- not a qualified thing + +lexCharacter :: Lex a Token +lexCharacter = do -- We need to keep track of not only character constants but also TH 'x and ''T + -- We've seen ' so far + s <- getInput + case s of + '\'':_ -> discard 1 >> return THTyQuote + '\\':_ -> do + c <- lexEscape + matchQuote + return (Character c) + c:'\'':_ -> discard 2 >> return (Character c) + _ -> return THVarQuote + + where matchQuote = matchChar '\'' "Improperly terminated character constant" + + +lexString :: Lex a Token +lexString = loop "" + where + loop s = do + r <- getInput + case r of + '\\':'&':_ -> do + discard 2 + loop s + '\\':c:_ | isSpace c -> do + discard 1 + lexWhiteChars + matchChar '\\' "Illegal character in string gap" + loop s + | otherwise -> do + ce <- lexEscape + loop (ce:s) + '"':_ -> do + discard 1 + return (StringTok (reverse s)) + c:_ -> do + discard 1 + loop (c:s) + [] -> fail "Improperly terminated string" + + lexWhiteChars :: Lex a () + lexWhiteChars = do + s <- getInput + case s of + '\n':_ -> do + lexNewline + lexWhiteChars + '\t':_ -> do + lexTab + lexWhiteChars + c:_ | isSpace c -> do + discard 1 + lexWhiteChars + _ -> return () + +lexEscape :: Lex a Char +lexEscape = do + discard 1 + r <- getInput + case r of + +-- Production charesc from section B.2 (Note: \& is handled by caller) + + 'a':_ -> discard 1 >> return '\a' + 'b':_ -> discard 1 >> return '\b' + 'f':_ -> discard 1 >> return '\f' + 'n':_ -> discard 1 >> return '\n' + 'r':_ -> discard 1 >> return '\r' + 't':_ -> discard 1 >> return '\t' + 'v':_ -> discard 1 >> return '\v' + '\\':_ -> discard 1 >> return '\\' + '"':_ -> discard 1 >> return '\"' + '\'':_ -> discard 1 >> return '\'' + +-- Production ascii from section B.2 + + '^':c:_ -> discard 2 >> cntrl c + 'N':'U':'L':_ -> discard 3 >> return '\NUL' + 'S':'O':'H':_ -> discard 3 >> return '\SOH' + 'S':'T':'X':_ -> discard 3 >> return '\STX' + 'E':'T':'X':_ -> discard 3 >> return '\ETX' + 'E':'O':'T':_ -> discard 3 >> return '\EOT' + 'E':'N':'Q':_ -> discard 3 >> return '\ENQ' + 'A':'C':'K':_ -> discard 3 >> return '\ACK' + 'B':'E':'L':_ -> discard 3 >> return '\BEL' + 'B':'S':_ -> discard 2 >> return '\BS' + 'H':'T':_ -> discard 2 >> return '\HT' + 'L':'F':_ -> discard 2 >> return '\LF' + 'V':'T':_ -> discard 2 >> return '\VT' + 'F':'F':_ -> discard 2 >> return '\FF' + 'C':'R':_ -> discard 2 >> return '\CR' + 'S':'O':_ -> discard 2 >> return '\SO' + 'S':'I':_ -> discard 2 >> return '\SI' + 'D':'L':'E':_ -> discard 3 >> return '\DLE' + 'D':'C':'1':_ -> discard 3 >> return '\DC1' + 'D':'C':'2':_ -> discard 3 >> return '\DC2' + 'D':'C':'3':_ -> discard 3 >> return '\DC3' + 'D':'C':'4':_ -> discard 3 >> return '\DC4' + 'N':'A':'K':_ -> discard 3 >> return '\NAK' + 'S':'Y':'N':_ -> discard 3 >> return '\SYN' + 'E':'T':'B':_ -> discard 3 >> return '\ETB' + 'C':'A':'N':_ -> discard 3 >> return '\CAN' + 'E':'M':_ -> discard 2 >> return '\EM' + 'S':'U':'B':_ -> discard 3 >> return '\SUB' + 'E':'S':'C':_ -> discard 3 >> return '\ESC' + 'F':'S':_ -> discard 2 >> return '\FS' + 'G':'S':_ -> discard 2 >> return '\GS' + 'R':'S':_ -> discard 2 >> return '\RS' + 'U':'S':_ -> discard 2 >> return '\US' + 'S':'P':_ -> discard 2 >> return '\SP' + 'D':'E':'L':_ -> discard 3 >> return '\DEL' + +-- Escaped numbers + + 'o':c:_ | isOctDigit c -> do + discard 1 + n <- lexOctal + checkChar n + 'x':c:_ | isHexDigit c -> do + discard 1 + n <- lexHexadecimal + checkChar n + c:_ | isDigit c -> do + n <- lexDecimal + checkChar n + + _ -> fail "Illegal escape sequence" + + where + checkChar n | n <= 0x01FFFF = return (chr (fromInteger n)) + checkChar _ = fail "Character constant out of range" + +-- Production cntrl from section B.2 + + cntrl :: Char -> Lex a Char + cntrl c | c >= '@' && c <= '_' = return (chr (ord c - ord '@')) + cntrl _ = fail "Illegal control character" + +-- assumes at least one octal digit +lexOctal :: Lex a Integer +lexOctal = do + ds <- lexWhile isOctDigit + return (parseInteger 8 ds) + +-- assumes at least one hexadecimal digit +lexHexadecimal :: Lex a Integer +lexHexadecimal = do + ds <- lexWhile isHexDigit + return (parseInteger 16 ds) + +-- assumes at least one decimal digit +lexDecimal :: Lex a Integer +lexDecimal = do + ds <- lexWhile isDigit + return (parseInteger 10 ds) + +-- Stolen from Hugs's Prelude +parseInteger :: Integer -> String -> Integer +parseInteger radix ds = + foldl1 (\n d -> n * radix + d) (map (toInteger . digitToInt) ds) diff --git a/Test/examples/RealHoogle.hs b/Test/examples/RealHoogle.hs new file mode 100644 --- /dev/null +++ b/Test/examples/RealHoogle.hs @@ -0,0 +1,254 @@ +{-| + Parse a list of flags supported in any of the front ends. + + Returns the flags in a data structure, along with any invalid flags. + + Deal with any files/include files in this stage. +-} + +module CmdLine.Flag( + CmdFlag(..), flagsHelp, + flagsWebArgs, flagsWebQuery, flagsCmdLine + ) where + +import General.Code +import General.Glob + +--------------------------------------------------------------------- +-- The flags + +data CmdFlag = Version -- ^ Version information + | Web -- ^ Operate as a CGI process + | Help -- ^ Help text + | Test -- ^ Run the regression tests + | Color Bool -- ^ Colors on the console + | Start Int -- ^ First result to show + | Count Int -- ^ Number of results to show + | Convert FilePath -- ^ Convert a database + | Output FilePath -- ^ Output file + | Dump String -- ^ Dump a database to a file (optional section) + | DataFile FilePath -- ^ Database location + | Verbose -- ^ Display verbose information + | Info -- ^ Display as much information as you can + | Debug -- ^ Do debugging activities + | Include FilePath -- ^ Include directory + | TestFile FilePath -- ^ Run tests in a file + | Rank FilePath -- ^ Generate rankings + | Combine FilePath -- ^ Merge a set of databases + | Mode String -- ^ Web modes + deriving (Show,Eq {-! Enum !-} ) + + +-- | In which circumstances are you allowed to pass this command +data Permission = PWebArgs | PWebQuery | PCmdLine | PMultiple + deriving (Show,Eq) + +data Argument = ArgNone CmdFlag + | ArgBool (Bool -> CmdFlag) + | ArgInt (Int -> CmdFlag) + | ArgNat (Int -> CmdFlag) + | ArgPos (Int -> CmdFlag) + | ArgFileIn (FilePath -> CmdFlag) [String] + | ArgFileOut (FilePath -> CmdFlag) + | ArgDir (FilePath -> CmdFlag) + | ArgStr (String -> CmdFlag) + +instance Show Argument where + show (ArgNone _) = "" + show (ArgInt _) = "INT" + show (ArgNat _) = "NAT" + show (ArgPos _) = "POS" + show (ArgBool _) = "BOOL" + show (ArgFileIn _ _) = "FILE" + show (ArgFileOut _) = "FILE" + show (ArgDir _) = "DIR" + show (ArgStr _) = "STR" + + +data FlagInfo = FlagInfo { + argument :: Argument, + names :: [String], + permissions :: [Permission], + description :: String + } + +flagInfo = + [f (ArgNone Version) ["version","ver"] [PCmdLine] "Print out version information" + ,f (ArgNone Help) ["?","help","h"] [PCmdLine] "Show help message" + ,f (ArgNone Web) ["w","web"] [PCmdLine] "Run as though it was a CGI script" + ,f (ArgBool Color) ["c","color","col","colour"] [PCmdLine] "Show color output (default=false)" + ,f (ArgPos Start) ["s","start"] [PCmdLine,PWebArgs] "First result to show (default=1)" + ,f (ArgPos Count) ["n","count","length","len"] [PCmdLine,PWebArgs] "Number of results to show (default=all)" + ,f (ArgNone Test) ["test"] [PCmdLine] "Run the regression tests" + ,f (ArgFileIn Convert ["txt"]) ["convert"] [PCmdLine,PMultiple] "Convert a database" + ,f (ArgFileOut Output) ["output"] [PCmdLine] "Output file for convert" + ,f (ArgStr Dump) ["dump"] [PCmdLine] "Dump a database for debugging" + ,f (ArgFileIn DataFile ["hoo"]) ["d","data"] [PCmdLine,PMultiple] "Database file" + ,f (ArgNone Verbose) ["v","verbose"] [PCmdLine] "Display verbose information" + ,f (ArgNone Info) ["info"] [PCmdLine] "Display full information on an entry" + ,f (ArgNone Debug) ["debug"] [PCmdLine] "Debugging only" + ,f (ArgDir Include) ["i","include"] [PCmdLine,PMultiple] "Include directories" + ,f (ArgFileIn TestFile ["txt"]) ["testfile"] [PCmdLine,PMultiple] "Run tests from a file" + ,f (ArgFileIn Rank ["txt"]) ["rank"] [PCmdLine,PMultiple] "Generate ranking scores" + ,f (ArgFileIn Combine ["hoo"]) ["combine"] [PCmdLine,PMultiple] "Combine multiple databases" + ,f (ArgStr Mode) ["mode"] [PCmdLine,PWebArgs] "Web mode" + ] + where f = FlagInfo + + +cmdFlagBadArg flag typ "" = "Missing argument to flag " ++ flag ++ ", expected argument of type " ++ typ +cmdFlagBadArg flag "" x = "Unexpected argument to flag " ++ flag ++ ", got \"" ++ x ++ "\"" +cmdFlagBadArg flag typ x = "Bad argument to flag " ++ flag ++ ", expected argument of type " ++ typ ++ ", got \"" ++ x ++ "\"" + +cmdFlagPermission flag = "Flag not allowed when running in this mode, flag " ++ flag + +cmdFlagUnknown flag = "Unknown flag " ++ flag + +cmdFlagDuplicate flag = "The flag " ++ flag ++ " may only occur once, but occured multiple times" + + +--------------------------------------------------------------------- +-- Operations on Flags + +-- | flags that are passed in through web arguments, +-- i.e. ?foo=bar&... +flagsWebArgs :: [(String,String)] -> IO ([CmdFlag],[String]) +flagsWebArgs = parseFlags PWebArgs + + +-- | flags that are given in the web query string +flagsWebQuery :: [(String,String)] -> IO ([CmdFlag],[String]) +flagsWebQuery = parseFlags PWebQuery + + +-- | flags that are given in a query on the command line +flagsCmdLine :: [(String,String)] -> IO ([CmdFlag],[String]) +flagsCmdLine = parseFlags PCmdLine + + +flagsHelp :: String +flagsHelp = unlines $ map f res + where + f (a,b,c) = " " ++ (if null a then " " else "--" ++ a ++ ",") ++ + " --" ++ b ++ replicate (maxLong - length b) ' ' ++ + " " ++ c + + maxLong = maximum $ map (length . snd3) res + res = [ (shortOpt (names i), longOpt (names i) ++ typ (argument i), description i) + | i <- flagInfo, PCmdLine `elem` permissions i] + + shortOpt ([x]:_) = [x] + shortOpt _ = "" + + longOpt ([_]:x:_) = x + longOpt (x:_) = x + + typ x = ['='|s/=""] ++ s + where s = show x + + +--------------------------------------------------------------------- +-- Parsing Flags + +-- TODO: check no flag is specified twice +-- TODO: Fix a bug, try /merge=t1;t2 and you get [t1,t1,t2,t2] +parseFlags :: Permission -> [(String,String)] -> IO ([CmdFlag],[String]) +parseFlags perm xs = do + let args = concatMap (parseFlag perm) xs + inc = [x | Right (_,_,_,Include x) <- args] + incs <- mapM globDir $ ["."|null inc] ++ inc + (a,b) <- mapAndUnzipM (f incs) args + return ([Include "."|null inc] ++ concat a, concat b) + where + f inc (Right (_,val,FlagInfo{argument=ArgFileIn gen exts},_)) = do + let vals = parseFile val + files <- concatMapM (globFile inc exts) vals + return (map gen files, []) + f inc (Left v) = return ([],[v]) + f inc (Right (_,_,_,v)) = return ([v],[]) + + +-- does all validity checks apart from checking for duplicate flags +parseFlag :: Permission -> (String, String) -> [Either String (String,String,FlagInfo,CmdFlag)] +parseFlag perm (key,val) + | isNothing m = [Left $ cmdFlagUnknown key] + | perm `notElem` permissions flg = [Left $ cmdFlagPermission key] + | null arg = [Left $ cmdFlagBadArg key (show $ argument flg) val] + | otherwise = [Right (key,val,flg,a) | a <- arg] + where + key2 = lower key + m@ ~(Just flg) = listToMaybe [i | i <- flagInfo, key2 `elem` names i] + arg = parseArg (argument flg) val + + +parseArg :: Argument -> String -> [CmdFlag] +parseArg (ArgNone v) xs = [v | null xs] +parseArg (ArgStr v) xs = [v xs] +parseArg (ArgBool v) xs = map v $ parseBool xs +parseArg (ArgNat v) xs = map v $ parseNat xs +parseArg (ArgInt v) xs = map v $ parseInt xs +parseArg (ArgPos v) xs = map v $ parsePos xs +parseArg (ArgFileIn v _) xs = map v $ parseFile xs +parseArg (ArgFileOut v) xs = map v $ parseFile xs +parseArg (ArgDir v) xs = map v $ parseFile xs + + +parseNat, parsePos, parseInt :: String -> [Int] +parseNat = filter (>= 0) . parseInt +parsePos = filter (> 0) . parseInt +parseInt x = [a | (a,"") <- reads x] + +parseFile :: String -> [String] +parseFile = splitSearchPath + +parseBool :: String -> [Bool] +parseBool v | v2 `elem` ["","on","yes","1","true","meep"] = [True] + | v2 `elem` ["off","no","0","false","moop"] = [False] + | otherwise = [] + where v2 = lower v + + + +-------------------------------------------------------- +-- DERIVES GENERATED CODE +-- DO NOT MODIFY BELOW THIS LINE +-- CHECKSUM: 1401092643 + +instance Enum CmdFlag + where toEnum 0 = Version{} + toEnum 1 = Web{} + toEnum 2 = Help{} + toEnum 3 = Test{} + toEnum 4 = Color{} + toEnum 5 = Start{} + toEnum 6 = Count{} + toEnum 7 = Convert{} + toEnum 8 = Output{} + toEnum 9 = Dump{} + toEnum 10 = DataFile{} + toEnum 11 = Verbose{} + toEnum 12 = Info{} + toEnum 13 = Debug{} + toEnum 14 = Include{} + toEnum 15 = TestFile{} + toEnum 16 = Rank{} + toEnum 17 = Combine{} + toEnum n = error ((++) "toEnum " ((++) (show n) ", not defined for CmdFlag")) + fromEnum (Version {}) = 0 + fromEnum (Web {}) = 1 + fromEnum (Help {}) = 2 + fromEnum (Test {}) = 3 + fromEnum (Color {}) = 4 + fromEnum (Start {}) = 5 + fromEnum (Count {}) = 6 + fromEnum (Convert {}) = 7 + fromEnum (Output {}) = 8 + fromEnum (Dump {}) = 9 + fromEnum (DataFile {}) = 10 + fromEnum (Verbose {}) = 11 + fromEnum (Info {}) = 12 + fromEnum (Debug {}) = 13 + fromEnum (Include {}) = 14 + fromEnum (TestFile {}) = 15 + fromEnum (Rank {}) = 16 + fromEnum (Combine {}) = 17 diff --git a/Test/examples/RealTagSoup.hs b/Test/examples/RealTagSoup.hs new file mode 100644 --- /dev/null +++ b/Test/examples/RealTagSoup.hs @@ -0,0 +1,395 @@ +{-# OPTIONS_GHC -w #-} + +{- +The XML spec is done mainly from memory. The only special bits are: + +Attributes +---------- + +"foo" as an attribute comes out as an attribute with a value and no text +to allow DOCTYPE tags to get parsed as normal. + +References (aka Character and Entity References) +---------- + +A character reference is one of: + +entity = '&#' [0-9]+ ';' + | '&#x' [0-9a-fA-F]+ ';' + | '&' name ';' + +The maximum character reference is 0x10FFFF + +name = (letter | '_' | ':') (namechar)* +namechar = letter | digit | '.' | '-' | '_' | ':' | combiningchar | extender +combiningchar and extender are assumed to be empty +letter = isAlpha +digit = isDigit +-} + + +module Text.HTML.TagSoup.Parser( + parseTags, parseTagsOptions, + ParseOptions(..), parseOptions + ) where + +import Text.HTML.TagSoup.Type +import Text.HTML.TagSoup.Entity +import Control.Monad.State +import Data.Char +import Data.List +import Data.Maybe + + +infix 9 ?-> + +(?->) :: Bool -> [x] -> [x] +(?->) b true = if b then true else [] + +--------------------------------------------------------------------- +-- * ParseOptions + +data ParseOptions = ParseOptions + {optTagPosition :: Bool -- ^ Should 'TagPosition' values be given before every item + ,optTagWarning :: Bool -- ^ Should 'TagWarning' values be given + ,optLookupEntity :: String -> [Tag] -- ^ How to lookup an entity + ,optMaxEntityLength :: Maybe Int -- ^ The maximum length of an entities content + -- (Nothing for no maximum, default to 10) + } + + +-- Default 'ParseOptions' structure +parseOptions :: ParseOptions +parseOptions = ParseOptions False False f (Just 10) + where + f x = case lookupEntity x of + Nothing -> [TagText $ "&" ++ x ++ ";", TagWarning $ "Unknown entity: &" ++ x ++ ";"] + Just x -> [TagText [x]] + + +parseTags :: String -> [Tag] +parseTags = parseTagsOptions parseOptions + +tagWarn :: ParseOptions -> String -> [Tag] +tagWarn opts x = [TagWarning x | optTagWarning opts] + +--------------------------------------------------------------------- +-- * Positions + +-- All positions are stored as a row and a column, with (1,1) being the +-- top-left position + +data Position = Position !Row !Column + + +updateOnString :: Position -> String -> Position +updateOnString = foldl' updateOnChar + +updateOnChar :: Position -> Char -> Position +updateOnChar (Position r c) x = case x of + '\n' -> Position (r+1) c + '\t' -> Position r (c + 8 - mod (c-1) 8) + _ -> Position r (c+1) + + +tagPos :: ParseOptions -> Position -> [Tag] +tagPos opts (Position r c) = [TagPosition r c | optTagPosition opts] + +tagPosWarn :: ParseOptions -> Position -> String -> [Tag] +tagPosWarn opts p x = optTagWarning opts ?-> (tagPos opts p ++ [TagWarning x]) + +tagPosWarnFix :: ParseOptions -> Position -> [Tag] -> [Tag] +tagPosWarnFix opts p = addPositions . remWarnings + where + remWarnings = if optTagWarning opts then id else filter (not . isTagWarning) + addPositions = concatMap (\x -> tagPos opts p ++ [x]) + + +--------------------------------------------------------------------- +-- * Driver + +parseTagsOptions :: ParseOptions -> String -> [Tag] +parseTagsOptions opts x = mergeTexts $ evalState (parse opts) $ Value x (Position 0 0) + + +-- | Combine adjacent text nodes. +-- +-- If two text nodes are separated only a position node, delete the position. +-- If two text nodes are separated only by a warning, move the warning afterwards. +-- If a position immediately proceeds a warning, count that into the warning. +-- +-- Note: this function leaks stack on Hugs. +mergeTexts :: [Tag] -> [Tag] +mergeTexts (TagText x:xs) = (TagText $ concat $ x:texts) : warns ++ mergeTexts rest + where + (texts,warns,rest) = f xs + + f (TagText x:xs) = (x:a,b,c) + where (a,b,c) = f xs + f (TagPosition _ _:TagText x:xs) = (x:a,b,c) + where (a,b,c) = f xs + + f (p@TagPosition{}:TagWarning y:xs) = (a,p:TagWarning y:b,c) + where (a,b,c) = f xs + f (TagWarning x:xs) = (a,TagWarning x:b,c) + where (a,b,c) = f xs + + f xs = ([],[],xs) + +mergeTexts (x:xs) = x : mergeTexts xs +mergeTexts [] = [] + + +--------------------------------------------------------------------- +-- * Combinators + +data Value = Value String !Position + +type Parser a = State Value a + + +isNameCharFirst x = isAlphaNum x || x `elem` "_:" +isNameChar x = isAlphaNum x || x `elem` "-_:." + +-- Read and consume n characters from the stream, updating the position. +-- Highly likely to be a potential for space leaks from this, unless @n@ is bounded. +consume :: Int -> Parser () +consume n = do + Value s p <- get + let (a,b) = splitAt n s + put $ Value b (updateOnString p a) + + +-- Break once an end string is encountered. +-- Return the string before, and a boolean indicating if the end was matched. +breakOn :: String -> Parser (String,Bool) +breakOn end = do + Value s p <- get + if null s then + return ("",True) + else if end `isPrefixOf` s then + consume (length end) >> return ("",False) + else do + consume 1 + ~(a,b) <- breakOn end + return (head s:a,b) + +-- Break after an HTML name (entity, attribute or tag name) +-- Note: potential space leak with consume at the end +breakName :: Parser String +breakName = do + Value s p <- get + if not (null s) && isNameCharFirst (head s) then do + let (a,b) = span isNameChar s + consume (length a) + return a + else + return "" + +-- Break after a number has been read +-- Note: potential space leak with consume at the end +breakNumber :: Parser (Maybe Int) +breakNumber = do + Value s p <- get + if not (null s) && isDigit (head s) then do + let (a,b) = span isDigit s + consume (length a) + return $ Just $ read a + else + return Nothing + + +-- Drop a number of spaces +-- Note: potential space leak with consume at the end +dropSpaces :: Parser () +dropSpaces = do + Value s p <- get + let n = length $ takeWhile isSpace s + consume n + + +--------------------------------------------------------------------- +-- * Parser + +parse :: ParseOptions -> Parser [Tag] +parse opts = do + Value s p <- get + case s of + '<':'!':'-':'-':_ -> consume 4 >> comment opts p + '<':'/':_ -> consume 2 >> close opts p + '<':_ -> consume 1 >> open opts p + [] -> return [] + '&':_ -> do + consume 1 + s <- entity opts p + rest <- parse opts + return $ s ++ rest + s:ss -> do + consume 1 + rest <- parse opts + return $ tagPos opts p ++ [TagText [s]] ++ rest + +-- have read "" + rest <- parse opts + return $ tagPos opts p1 ++ [TagComment inner] ++ + (bad ?-> tagPosWarn opts p1 "Unexpected end when looking for \"-->\"") ++ + rest + + +close opts p1 = do + name <- breakName + dropSpaces + ~(Value s p) <- get + rest <- f s + return $ tagPos opts p1 ++ [TagClose name] ++ + (null name ?-> tagPosWarn opts p1 "Empty name in close tag") ++ + rest + where + f ('>':s) = do + consume 1 + rest <- parse opts + return rest + + f _ = do + ~(_,bad) <- breakOn ">" + rest <- parse opts + return $ tagPosWarn opts p1 "Junk in closing tag" ++ + bad ?-> tagPosWarn opts p1 "Unexpected end when looking for \">\"" ++ + rest + + +-- an open tag, perhaps > return [head s] else return "" + name <- liftM (prefix++) breakName + if null name then do + rest <- parse opts + return $ tagPos opts p1 ++ [TagText ('<':prefix)] ++ tagPosWarn opts p1 "Expected name of tag" ++ rest + else do + ~(atts,shut,warns) <- attribs opts p1 + rest <- parse opts + return $ tagPos opts p1 ++ [TagOpen name atts] ++ + shut ?-> (tagPos opts p1 ++ [TagClose name]) ++ + warns ++ rest + + +-- read a list of attributes +-- return (the attributes read, if the tag is self-shutting, any warnings) +attribs :: ParseOptions -> Position -> Parser ([Attribute],Bool,[Tag]) +attribs opts p1 = do + dropSpaces + Value s p <- get + case s of + '/':'>':_ -> consume 2 >> return ([],True ,[]) + '>':_ -> consume 1 >> return ([],False,[]) + x:xs | x `elem` "'\"" -> do + ~(val,warns1) <- value opts + ~(atts,shut,warns2) <- attribs opts p1 + return (("",val):atts,shut,warns1++warns2) + [] -> return ([],False,tagPosWarn opts p1 "Unexpected end when looking for \">\"") + _ -> attrib opts p1 + + +-- read a single attribute +-- return (the attributes read, if the tag is self-shutting, any warnings) +attrib :: ParseOptions -> Position -> Parser ([Attribute],Bool,[Tag]) +attrib opts p1 = do + name <- breakName + if null name then do + consume 1 + ~(atts,shut,warns) <- attribs opts p1 + return (atts,shut,tagPosWarn opts p1 "Junk character in tag" ++ warns) + else do + ~(Value sold p) <- get + dropSpaces + ~(Value s p) <- get + ~(val,warns1) <- f sold s + ~(atts,shut,warns2) <- attribs opts p1 + return ((name,val):atts,shut,warns1++warns2) + where + f sold ('=':s) = consume 1 >> dropSpaces >> value opts + f sold s | not $ junk sold = return ([], []) + | otherwise = do + ~(Value s p) <- get + dropJunk + return ([], tagPosWarn opts p "Junk character in tag") + + junk ('/':'>':_) = False + junk ('>':_) = False + junk (c:cs) | not $ isSpace c = True + junk _ = False + + dropJunk = do + ~(Value s p) <- get + when (junk s) $ consume 1 >> dropJunk + + +-- read a single value +-- return (value,warnings) +value :: ParseOptions -> Parser (String,[Tag]) +value opts = do + Value s p <- get + case s of + '\"':_ -> consume 1 >> f p True "\"" + '\'':_ -> consume 1 >> f p True "\'" + _ -> f p False ">" + where + f p1 quote end = do + Value s p <- get + case s of + '&':_ -> do + consume 1 + ~(cs1,warns1) <- entityString opts p + ~(cs2,warns2) <- f p1 quote end + return (cs1++cs2,warns1++warns2) + '/':'>':_ | not quote -> do + return ([],[]) + c:_ | c `elem` end || (not quote && isSpace c) -> do + if quote then consume 1 else return () + return ([],[]) + c:_ -> do + consume 1 + ~(cs,warns) <- f p1 quote end + return (c:cs,warns) + [] -> return ([],tagPosWarn opts p1 "Unexpected end in attibute value") + + + +-- have seen an &, and have consumed it +-- return a [Tag] to go in a tag stream +entity :: ParseOptions -> Position -> Parser [Tag] +entity opts p1 = do + Value s p <- get + case s of + '#':'x':_ -> f "#x" isHexDigit + '#':_ -> f "#" isDigit + _ -> f "" isNameChar + where + f prefix match = do + consume (length prefix) + g match (reverse prefix) (fromMaybe maxBound (optMaxEntityLength opts)) + + g match buf bound | bound < 0 = return $ + tagPos opts p1 ++ [TagText ('&':reverse buf)] ++ + tagPosWarn opts p1 "Unexpected '&' not in an entity" + + g match buf bound = do + Value s p <- get + case s of + ';':_ -> do + consume 1 + return $ tagPosWarnFix opts p1 $ optLookupEntity opts (reverse buf) + x:xs | match x -> consume 1 >> g match (x:buf) (bound-1) + _ -> g match buf (-1) + + + +-- return the tag and some position information +entityString :: ParseOptions -> Position -> Parser (String,[Tag]) +entityString opts p = do + tags <- entity opts p + let warnings = tagPosWarnFix opts p $ filter isTagWarning tags + return (innerText tags, warnings) diff --git a/Test/examples/RecordInfixSelector.hs b/Test/examples/RecordInfixSelector.hs new file mode 100644 --- /dev/null +++ b/Test/examples/RecordInfixSelector.hs @@ -0,0 +1,3 @@ +data RecordWithInfixSelector = Cons { (<>) :: Int -> Int } + +idRecord = Cons { (<>) = id } diff --git a/Test/examples/RecordWildcards.hs b/Test/examples/RecordWildcards.hs new file mode 100644 --- /dev/null +++ b/Test/examples/RecordWildcards.hs @@ -0,0 +1,5 @@ +{-# LANGUAGE RecordWildCards, NamedFieldPuns #-} + +data Foo = Foo {a :: Int, b :: Int} + +foo Foo{b, ..} = a diff --git a/Test/examples/RelaxedDo.hs b/Test/examples/RelaxedDo.hs new file mode 100644 --- /dev/null +++ b/Test/examples/RelaxedDo.hs @@ -0,0 +1,13 @@ +module Main where + +import Control.Monad + +main :: IO () +main = do + when ( 2 > 1) $ do + putStrLn "a" + putStrLn "b" + +nestedDoBlocks = getChar >>= (\c1 -> do + getChar >>= (\c2 -> do + getChar >>= (\c3 -> return [c1,c2,c3]))) diff --git a/Test/examples/SCCPragmas.hs b/Test/examples/SCCPragmas.hs new file mode 100644 --- /dev/null +++ b/Test/examples/SCCPragmas.hs @@ -0,0 +1,3 @@ +module SCCPragmas where + +x = {-# SCC "wibble" #-} 3 diff --git a/Test/examples/ScopedTypeVariables.hs b/Test/examples/ScopedTypeVariables.hs new file mode 100644 --- /dev/null +++ b/Test/examples/ScopedTypeVariables.hs @@ -0,0 +1,12 @@ +{-# LANGUAGE ScopedTypeVariables #-} + +test :: IO Char +test = do + x :: Char <- getChar + return x + + +value :: String = "Hello" + +forallTest :: forall x . Eq x => x -> x +forallTest x = if x == x then (undefined :: x) else x diff --git a/Test/examples/SimpleDeriving.hs b/Test/examples/SimpleDeriving.hs new file mode 100644 --- /dev/null +++ b/Test/examples/SimpleDeriving.hs @@ -0,0 +1,1 @@ +data T = T deriving Eq diff --git a/Test/examples/SingleClassAsst.hs b/Test/examples/SingleClassAsst.hs new file mode 100644 --- /dev/null +++ b/Test/examples/SingleClassAsst.hs @@ -0,0 +1,4 @@ +module Test where + +foo :: (Eq a) => a -> a +foo x = x diff --git a/Test/examples/SpecializeInstance.hs b/Test/examples/SpecializeInstance.hs new file mode 100644 --- /dev/null +++ b/Test/examples/SpecializeInstance.hs @@ -0,0 +1,4 @@ +instance Sized a => Sized (Digit a) where + {-# SPECIALIZE instance Sized (Digit (Elem a)) #-} + {-# SPECIALIZE instance Sized (Digit (Node a)) #-} + size xs = foldl (\ i x -> i + size x) 0 xs diff --git a/Test/examples/Testing.hs b/Test/examples/Testing.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Testing.hs @@ -0,0 +1,2 @@ +{-# LINE 5 "templates\GenericTemplate.hs" #-} +main = return () diff --git a/Test/examples/TupleSections.hs b/Test/examples/TupleSections.hs new file mode 100644 --- /dev/null +++ b/Test/examples/TupleSections.hs @@ -0,0 +1,3 @@ +{-# LANGUAGE TupleSections #-} + +foo x = (1,,) x 3 diff --git a/Test/examples/TypeFunctions.hs b/Test/examples/TypeFunctions.hs new file mode 100644 --- /dev/null +++ b/Test/examples/TypeFunctions.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TypeFamilies, KindSignatures #-} + +data Id = Id + +type family Rep (f :: * -> *) x :: * + +type instance Rep Id x = x diff --git a/Test/examples/TypeOperatorsTest.hs b/Test/examples/TypeOperatorsTest.hs new file mode 100644 --- /dev/null +++ b/Test/examples/TypeOperatorsTest.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE TypeOperators, FlexibleContexts, FlexibleInstances #-} + +f :: ArrowXml (~>) => a ~> a +f = undefined diff --git a/Test/examples/Unicode.hs b/Test/examples/Unicode.hs new file mode 100644 --- /dev/null +++ b/Test/examples/Unicode.hs @@ -0,0 +1,118 @@ +{-# LANGUAGE UnicodeSyntax #-} +module Main where + +import System.Environment + +main :: IO () +main = do + as ← getArgs + print $ as + print $ test 0 + print $ test2 0 + print $ testRewrite 0 + print $ testRewriteReverse 0 + print $ testRewrite2 0 + print $ testRewriteReverse2 0 + +test :: a → Bool +test x = pi + where + f = replicate 2000 x + i = repeat x + pf = f |> 300 + pi = i |> 300 + +test2 :: a → (Bool,Bool) +test2 x = (pf,pi) + where + f = replicate 2000 x + i = repeat x + pf = f |> 300 + pi = i |> 300 + +testRewrite :: a → Bool +testRewrite x = pi + where + f = replicate 2000 x + i = repeat x + lf = length f + li = length i + pf = lf > 300 + pi = li > 300 + +testRewriteReverse :: a → Bool +testRewriteReverse x = pi + where + f = replicate 2000 x + i = repeat x + lf = length f + li = length i + pf = 300 ≤ lf + pi = 300 ≤ li + +testRewrite2 :: a → (Bool,Bool) +testRewrite2 x = (length i > 300,300 > length i) + where +-- f = replicate 2000 x + i = repeat x +-- lf = length f +-- li = length i +-- pf = lf > 300 +-- pi = li > 300 + +testRewriteReverse2 :: a → (Bool,Bool) +testRewriteReverse2 x = (2000 < length i,length i > 20) + where + f = replicate 2000 x + i = repeat x + lf = length f + li = length i + pf = 2000 == lf + pi = lf ≥ li + + +lengthOP :: (Num a, Ord a) ⇒ Bool → (a → a → Bool) → [b] → a → Bool +lengthOP v (⊜) [] n = 0 ⊜ n +lengthOP v (⊜) xxs n = co xxs 0 + where + co (_:xs) c | n > c = co xs (c+1) + | otherwise = v + co [] c = c ⊜ n + +(≣) = (==) +(≤) = (<=) +(≥) = (>=) + +(|≣) = lengthOP False (≣) +(|<) = lengthOP False (<) +(|≤) = lengthOP False (≤) +(|>) = lengthOP True (>) +(|≥) = lengthOP True (≥) + +(|=) = lengthOP False (==) +(|==) = lengthOP False (==) +(|<=) = lengthOP False (<=) +(|>=) = lengthOP False (>=) + + +-- ≣≤≥ +(≣|) = flip (|≣) +(<|) = flip (|≥) +(≤|) = flip (|>) +(>|) = flip (|≤) +(≥|) = flip (|<) + +{-# RULES +-- length +"xs |≣ n" forall xs n. (length xs) == n = xs |≣ n +"xs |< n" forall xs n. (length xs) < n = xs |< n +"xs |≤ n" forall xs n. (length xs) <= n = xs |≤ n +"xs |> n" forall xs n. (length xs) > n = xs |> n +"xs |≥ n" forall xs n. (length xs) >= n = xs |≥ n + +"n ≣| xs" forall xs n. n == (length xs) = xs |≣ n +"n <| xs" forall xs n. n < (length xs) = xs |≥ n +"n ≤| xs" forall xs n. n <= (length xs) = xs |> n +"n >| xs" forall xs n. n > (length xs) = xs |≤ n +"n ≥| xs" forall xs n. n >= (length xs) = xs |< n + #-} diff --git a/Test/examples/UnicodeSyntax.hs b/Test/examples/UnicodeSyntax.hs new file mode 100644 --- /dev/null +++ b/Test/examples/UnicodeSyntax.hs @@ -0,0 +1,12 @@ +{-# LANGUAGE UnicodeSyntax #-} +module UnicodeSyntax where + +import System.Environment (getArgs) + +main :: IO () +main = do + as ← getArgs + print $ test 0 + +test :: Int → Bool +test x = x*5 == x+8 diff --git a/Test/examples/UnindentedPragmaClose.hs b/Test/examples/UnindentedPragmaClose.hs new file mode 100644 --- /dev/null +++ b/Test/examples/UnindentedPragmaClose.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE MultiParamTypeClasses +#-} +f :: Int +f = 4 diff --git a/Test/examples/WhereBlock.hs b/Test/examples/WhereBlock.hs new file mode 100644 --- /dev/null +++ b/Test/examples/WhereBlock.hs @@ -0,0 +1,3 @@ +hash ptr len = f len + where f h = return h + f p = (p `advancePtr` 1) diff --git a/Test/examples/WithKeyword.hs b/Test/examples/WithKeyword.hs new file mode 100644 --- /dev/null +++ b/Test/examples/WithKeyword.hs @@ -0,0 +1,1 @@ +with = 1 diff --git a/Test/failing.txt b/Test/failing.txt new file mode 100644 --- /dev/null +++ b/Test/failing.txt @@ -0,0 +1,3 @@ +Unicode.hs Fails if readFile is not Unicode-aware, i.e. if GHC 6.12 is not used. +UnicodeSyntax.hs Same as above. +ForeignImport.hs Shouldn't succeed. Lacks ForeignFunctionInterface pragma, but complains about missing TemplateHaskell. diff --git a/Test/printFail.txt b/Test/printFail.txt new file mode 100644 --- /dev/null +++ b/Test/printFail.txt @@ -0,0 +1,3 @@ +HexPrec.hs Uses hexadecimal notation to specify precedence of infix operator. We don't retain that info. +RealGHC.lhs Literate haskell. +SpecializeInstance.hs Prints SPECIALISE instead of SPECIALIZE. diff --git a/haskell-src-exts.cabal b/haskell-src-exts.cabal --- a/haskell-src-exts.cabal +++ b/haskell-src-exts.cabal @@ -1,5 +1,5 @@ Name: haskell-src-exts -Version: 1.9.4 +Version: 1.9.5 License: BSD3 License-File: LICENSE Author: Niklas Broberg @@ -31,6 +31,75 @@ Tested-with: GHC==6.10.2, GHC==6.10.4 Build-Type: Custom Cabal-Version: >= 1.2 +Extra-Source-Files: + CHANGELOG + Test/Runner.hs + Test/failing.txt + Test/printFail.txt + Test/examples/ArrowLayout.hs + Test/examples/Attributes.hs + Test/examples/BangPatterns.hs + Test/examples/Bug.hs + Test/examples/ByteStringUtils.hs + Test/examples/CParser.hs + Test/examples/ClassInstType.hs + Test/examples/DataHeadParen.hs + Test/examples/Directory.hs + Test/examples/EmptyAnn.hs + Test/examples/EmptyContext.hs + Test/examples/EmptyInstance.hs + Test/examples/EmptyList.hs + Test/examples/Ex1.hs + Test/examples/FamilyKindSig.hs + Test/examples/FixityTests.hs + Test/examples/ForeignImport.hs + Test/examples/GadtDeriving.hs + Test/examples/GenericTree.hs + Test/examples/GhcDeriving.hs + Test/examples/GroupKeyword.hs + Test/examples/HappyDoAction.hs + Test/examples/HaskellParser.hs + Test/examples/HexPrec.hs + Test/examples/Hyphen.hs + Test/examples/ImportSymbol.hs + Test/examples/IndentedWhere.hs + Test/examples/InfixParser.hs + Test/examples/LanguagePragma.hs + Test/examples/LineOptionsPragma.hs + Test/examples/LinePragma.hs + Test/examples/ListComp1.hs + Test/examples/MagicHash.hs + Test/examples/MultiCtxt.hs + Test/examples/NPlusK.hs + Test/examples/NestedAsPat.hs + Test/examples/PackageImport.hs + Test/examples/ParenFunBind.hs + Test/examples/Pragma.hs + Test/examples/QualifiedDot.hs + Test/examples/QuasiQuoteLines.hs + Test/examples/Rank2Types.hs + Test/examples/ReadP.hs + Test/examples/RealGHC.lhs + Test/examples/RealHSE.hs + Test/examples/RealHoogle.hs + Test/examples/RealTagSoup.hs + Test/examples/RecordInfixSelector.hs + Test/examples/RecordWildcards.hs + Test/examples/RelaxedDo.hs + Test/examples/SCCPragmas.hs + Test/examples/ScopedTypeVariables.hs + Test/examples/SimpleDeriving.hs + Test/examples/SingleClassAsst.hs + Test/examples/SpecializeInstance.hs + Test/examples/Testing.hs + Test/examples/TupleSections.hs + Test/examples/TypeFunctions.hs + Test/examples/TypeOperatorsTest.hs + Test/examples/Unicode.hs + Test/examples/UnicodeSyntax.hs + Test/examples/UnindentedPragmaClose.hs + Test/examples/WhereBlock.hs + Test/examples/WithKeyword.hs Flag base4 diff --git a/src/Language/Haskell/Exts/Pretty.hs b/src/Language/Haskell/Exts/Pretty.hs --- a/src/Language/Haskell/Exts/Pretty.hs +++ b/src/Language/Haskell/Exts/Pretty.hs @@ -334,8 +334,8 @@ markLine loc $ mySep ( [pretty don, ppContext context, pretty name] ++ map pretty nameList) - <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) - (map pretty constrList)) + <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) + (map pretty constrList)) $$$ ppDeriving derives) pretty (GDataDecl loc don context name nameList optkind gadtList derives) = @@ -344,7 +344,7 @@ mySep ( [pretty don, ppContext context, pretty name] ++ map pretty nameList ++ ppOptKind optkind ++ [text "where"]) $$$ ppBody classIndent (map pretty gadtList) - $$$ ppDeriving derives + $$$ ppBody letIndent [ppDeriving derives] pretty (TypeFamDecl loc name nameList optkind) = blankline $ @@ -889,25 +889,25 @@ instance Pretty Pat where prettyPrec _ (PVar name) = pretty name prettyPrec _ (PLit lit) = pretty lit - prettyPrec _ (PNeg p) = myFsep [char '-', pretty p] + prettyPrec p (PNeg pat) = parensIf (p > 0) $ myFsep [char '-', pretty pat] prettyPrec p (PInfixApp a op b) = parensIf (p > 0) $ - myFsep [pretty a, pretty (QConOp op), pretty b] - prettyPrec p (PApp n ps) = parensIf (p > 1) $ - myFsep (pretty n : map pretty ps) + myFsep [prettyPrec 1 a, pretty (QConOp op), prettyPrec 1 b] + prettyPrec p (PApp n ps) = parensIf (p > 1 && not (null ps)) $ + myFsep (pretty n : map (prettyPrec 2) ps) prettyPrec _ (PTuple ps) = parenList . map pretty $ ps prettyPrec _ (PList ps) = bracketList . punctuate comma . map pretty $ ps - prettyPrec _ (PParen p) = parens . pretty $ p + prettyPrec _ (PParen pat) = parens . pretty $ pat prettyPrec _ (PRec c fields) = pretty c <> (braceList . map pretty $ fields) -- special case that would otherwise be buggy prettyPrec _ (PAsPat name (PIrrPat pat)) = - myFsep [pretty name <> char '@', char '~' <> pretty pat] + myFsep [pretty name <> char '@', char '~' <> prettyPrec 2 pat] prettyPrec _ (PAsPat name pat) = - hcat [pretty name, char '@', pretty pat] + hcat [pretty name, char '@', prettyPrec 2 pat] prettyPrec _ PWildCard = char '_' - prettyPrec _ (PIrrPat pat) = char '~' <> pretty pat - prettyPrec _ (PatTypeSig _pos pat ty) = + prettyPrec _ (PIrrPat pat) = char '~' <> prettyPrec 2 pat + prettyPrec p (PatTypeSig _pos pat ty) = parensIf (p > 0) $ myFsep [pretty pat, text "::", pretty ty] prettyPrec p (PViewPat e pat) = parensIf (p > 0) $ myFsep [pretty e, text "->", pretty pat] @@ -934,7 +934,7 @@ prettyPrec _ (PExplTypeArg qn t) = myFsep [pretty qn, text "{|", pretty t, text "|}"] -- BangPatterns - prettyPrec _ (PBangPat p) = text "!" <> pretty p + prettyPrec _ (PBangPat pat) = text "!" <> prettyPrec 2 pat instance Pretty PXAttr where pretty (PXAttr n p) =