packages feed

haskell-src-exts 1.9.4 → 1.9.5

raw patch · 70 files changed

+13225/−14 lines, 70 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

+ CHANGELOG view
@@ -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.
+
+ Test/Runner.hs view
@@ -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<unexpected pass for " ++ file ++ ">") >> 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<unexpected pass for " ++ file ++ ">") >> 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
+ Test/examples/ArrowLayout.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE Arrows #-}
+module ArrowLayout where
+
+exp = proc () -> do
+  rec let e = 1 + i
+      i <- integral -< e
+  returnA -< e
+ Test/examples/Attributes.hs view
@@ -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:+     <http://graphviz.org/doc/info/attrs.html>++   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: <http://graphviz.org/doc/info/arrows.html>+--+--   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"+                      ]
+ Test/examples/BangPatterns.hs view
@@ -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
+ Test/examples/Bug.hs view
@@ -0,0 +1,2 @@+import Test.QuickCheck
+-- prop_susShortest = 2 > 1 ==> 1 /= 2
+ Test/examples/ByteStringUtils.hs view
@@ -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
+ Test/examples/CParser.hs view
@@ -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.+--+--   <permute> 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 "<built-in>" #-}+{-# LINE 1 "<command line>" #-}+{-# LINE 1 "GenericTemplate.hs" #-}+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp++{-# LINE 28 "GenericTemplate.hs" #-}+++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.
+ Test/examples/ClassInstType.hs view
@@ -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
+ Test/examples/DataHeadParen.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE TypeOperators #-}
+module DataHeadParen where
+
+data (a1 :< a2)  = Foo
+ Test/examples/Directory.hs view
@@ -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+<http://www.opengroup.org/onlinepubs/009695399/>), 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+-- <http://msdn.microsoft.com/en-us/library/aa365527.aspx> 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"
+ Test/examples/EmptyAnn.hs view
@@ -0,0 +1,1 @@+{-# ANN foo "Hlint: ignore Test4" #-}
+ Test/examples/EmptyContext.hs view
@@ -0,0 +1,1 @@+happyThen :: () => P a
+ Test/examples/EmptyInstance.hs view
@@ -0,0 +1,4 @@+instance Traversable Tree where++x :: Int+x = 1
+ Test/examples/EmptyList.hs view
@@ -0,0 +1,3 @@+module EmptyList where
+
+eAttrs = []
+ Test/examples/Ex1.hs view
@@ -0,0 +1,1 @@+yes = 1 where x = 1
+ Test/examples/FamilyKindSig.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE TypeFamilies #-}
+module FamilyKindSig where
+
+type family WithKindSig (a :: * -> *)
+ Test/examples/FixityTests.hs view
@@ -0,0 +1,3 @@+main = forM_ cmdReports $ \x -> do
+               putStrLn $ "Writing report to " ++ x ++ " ..."
+               writeReport x ideas
+ Test/examples/ForeignImport.hs view
@@ -0,0 +1,2 @@+foreign import ccall unsafe "getProgArgv"
+ getProgArgv :: Ptr CInt -> Ptr (Ptr CString) -> IO ()
+ Test/examples/GadtDeriving.hs view
@@ -0,0 +1,5 @@+{-# LANGUAGE GADTs #-}++data Foo where+    Foo :: Int -> Foo+    deriving (Eq,Ord,Typeable)
+ Test/examples/GenericTree.hs view
@@ -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)
+ Test/examples/GhcDeriving.hs view
@@ -0,0 +1,4 @@+++newtype CodeGenModule a = CGM (StateT CGMState IO a)+   deriving (Monad, MonadState [s], MonadIO)
+ Test/examples/GroupKeyword.hs view
@@ -0,0 +1,4 @@+-- {-# LANGUAGE TransformListComp #-}
+module GroupKeyword where
+
+a = map head $ group $ sort [1..100]
+ Test/examples/HappyDoAction.hs view
@@ -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
+ Test/examples/HaskellParser.hs view
@@ -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)
+ Test/examples/HexPrec.hs view
@@ -0,0 +1,6 @@+module HexPrec where
+
+(%%) :: Int -> Int -> Int
+a %% b = 0
+
+infixl 0x02 %%
+ Test/examples/Hyphen.hs view
@@ -0,0 +1,2 @@++foo x y = fromIntegral $ x-y+1
+ Test/examples/ImportSymbol.hs view
@@ -0,0 +1,1 @@+import Data.Generics hiding ((:*:))
+ Test/examples/IndentedWhere.hs view
@@ -0,0 +1,4 @@+
+f x = g
+  where g :: Int
+        g = 0
+ Test/examples/InfixParser.hs view
@@ -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
+ Test/examples/LanguagePragma.hs view
@@ -0,0 +1,1 @@+{-# LANGUAGE PatternGuards, ViewPatterns #-}
+ Test/examples/LineOptionsPragma.hs view
@@ -0,0 +1,3 @@+{-# OPTIONS #-}
+{-# LINE 49 "src/Language/C/Parser/Lexer.x" #-}
+module Fail where
+ Test/examples/LinePragma.hs view
@@ -0,0 +1,5 @@+{-# LINE 1 "Algebra.lhs" #-}+module Algebra where++{-# LINE 3 "Algebra.lhs" #-}+foo bar = bar
+ Test/examples/ListComp1.hs view
@@ -0,0 +1,1 @@+copyFiles =  [a | f ('.':)]
+ Test/examples/MagicHash.hs view
@@ -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'#
+ Test/examples/MultiCtxt.hs view
@@ -0,0 +1,6 @@+{-# LANGUAGE RankNTypes #-}
+
+module MultiCtxt where
+
+multipleCtx :: Eq a => (Show a => a)
+multipleCtx = undefined
+ Test/examples/NPlusK.hs view
@@ -0,0 +1,2 @@++f (n+3) = n
+ Test/examples/NestedAsPat.hs view
@@ -0,0 +1,3 @@+module NestedAsPat where
+
+nestedAsPat [x@(Just _)] = undefined
+ Test/examples/PackageImport.hs view
@@ -0,0 +1,5 @@+{-# LANGUAGE PackageImports #-}++import "haskell-src-exts" Language.Haskell.Exts++main = undefined
+ Test/examples/ParenFunBind.hs view
@@ -0,0 +1,3 @@+module ParenFunBind where
+
+(foo x) y = x + y
+ Test/examples/Pragma.hs view
@@ -0,0 +1,7 @@+++data Bar = Bar++instance Eq Bar where+    {-# INLINE (==) #-}+    a == b = error "here"
+ Test/examples/QualifiedDot.hs view
@@ -0,0 +1,3 @@+module QualifiedDot where
+
+twoDots = (Prelude..)
+ Test/examples/QuasiQuoteLines.hs view
@@ -0,0 +1,12 @@+{-# LANGUAGE QuasiQuotes #-}++import Here++str :: String+str = [$here|test +test +test test |]+++main :: IO()+main = do putStrLn str
+ Test/examples/Rank2Types.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE Rank2Types #-}++test :: Int -> forall a. [a] -> Int+test _ _ = 1
+ Test/examples/ReadP.hs view
@@ -0,0 +1,2 @@+{-# LANGUAGE TypeOperators #-}
+newtype ReadP a = R (forall b . (a -> P b) -> P b)
+ Test/examples/RealGHC.lhs view
@@ -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) = <rhs>+-- 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. <rhs>) 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}+
+ Test/examples/RealHSE.hs view
@@ -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     -- </+        | XEmptyTagClose    -- />+        | 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)
+ Test/examples/RealHoogle.hs view
@@ -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
+ Test/examples/RealTagSoup.hs view
@@ -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 "<!--"+comment opts p1 = do+    ~(inner,bad) <- breakOn "-->"+    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 <? or <!+open opts p1 = do+    Value s p <- get+    prefix <- if take 1 s `elem` ["!","?"] then consume 1 >> 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)
+ Test/examples/RecordInfixSelector.hs view
@@ -0,0 +1,3 @@+data RecordWithInfixSelector = Cons { (<>) :: Int -> Int }
+
+idRecord = Cons { (<>) = id }
+ Test/examples/RecordWildcards.hs view
@@ -0,0 +1,5 @@+{-# LANGUAGE RecordWildCards, NamedFieldPuns #-}++data Foo = Foo {a :: Int, b :: Int}++foo Foo{b, ..} = a
+ Test/examples/RelaxedDo.hs view
@@ -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])))
+ Test/examples/SCCPragmas.hs view
@@ -0,0 +1,3 @@+module SCCPragmas where
+
+x = {-# SCC "wibble" #-} 3
+ Test/examples/ScopedTypeVariables.hs view
@@ -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
+ Test/examples/SimpleDeriving.hs view
@@ -0,0 +1,1 @@+data T = T deriving Eq
+ Test/examples/SingleClassAsst.hs view
@@ -0,0 +1,4 @@+module Test where
+
+foo :: (Eq a) => a -> a
+foo x = x
+ Test/examples/SpecializeInstance.hs view
@@ -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
+ Test/examples/Testing.hs view
@@ -0,0 +1,2 @@+{-# LINE 5 "templates\GenericTemplate.hs" #-}
+main = return ()
+ Test/examples/TupleSections.hs view
@@ -0,0 +1,3 @@+{-# LANGUAGE TupleSections #-}
+
+foo x = (1,,) x 3
+ Test/examples/TypeFunctions.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TypeFamilies, KindSignatures #-}++data Id = Id++type family Rep (f :: * -> *) x :: *++type instance Rep Id x = x
+ Test/examples/TypeOperatorsTest.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE TypeOperators, FlexibleContexts, FlexibleInstances #-}++f :: ArrowXml (~>) => a ~> a+f = undefined
+ Test/examples/Unicode.hs view
@@ -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+  #-}
+ Test/examples/UnicodeSyntax.hs view
@@ -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
+ Test/examples/UnindentedPragmaClose.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE MultiParamTypeClasses+#-}+f :: Int+f = 4
+ Test/examples/WhereBlock.hs view
@@ -0,0 +1,3 @@+hash ptr len = f len
+ where f h = return h
+       f p = (p `advancePtr` 1)
+ Test/examples/WithKeyword.hs view
@@ -0,0 +1,1 @@+with = 1
+ Test/failing.txt view
@@ -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.
+ Test/printFail.txt view
@@ -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.
haskell-src-exts.cabal view
@@ -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
src/Language/Haskell/Exts/Pretty.hs view
@@ -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) =