language-c-quote (empty) → 0.2
raw patch · 19 files changed
+13101/−0 lines, 19 filesdep +HUnitdep +arraydep +basebuild-type:Customsetup-changed
Dependencies added: HUnit, array, base, bytestring, containers, exception-mtl, filepath, haskell-src-meta, language-c-quote, mainland-pretty, mtl, srcloc, syb, symbol, template-haskell
Files
- LICENSE +26/−0
- Language/C.hs +45/−0
- Language/C/Parser.hs +62/−0
- Language/C/Parser/Lexer.x +543/−0
- Language/C/Parser/Monad.hs +313/−0
- Language/C/Parser/Parser.y +2185/−0
- Language/C/Parser/Tokens.hs +405/−0
- Language/C/Pretty.hs +735/−0
- Language/C/Quote/Base.hs +567/−0
- Language/C/Quote/C.hs +79/−0
- Language/C/Quote/CUDA.hs +88/−0
- Language/C/Quote/GCC.hs +79/−0
- Language/C/Smart.hs +110/−0
- Language/C/Syntax.hs +557/−0
- Setup.hs +14/−0
- dist/build/Language/C/Parser/Lexer.hs +718/−0
- dist/build/Language/C/Parser/Parser.hs +6361/−0
- language-c-quote.cabal +73/−0
- tests/unit/Main.hs +141/−0
+ LICENSE view
@@ -0,0 +1,26 @@+Copyright (c) 2006-2010+ The President and Fellows of Harvard College.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions+are met:+1. Redistributions of source code must retain the above copyright+ notice, this list of conditions and the following disclaimer.+2. Redistributions in binary form must reproduce the above copyright+ notice, this list of conditions and the following disclaimer in the+ documentation and/or other materials provided with the distribution.+3. Neither the name of the University nor the names of its contributors+ may be used to endorse or promote products derived from this software+ without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+SUCH DAMAGE.
+ Language/C.hs view
@@ -0,0 +1,45 @@+-- Copyright (c) 2009+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C+-- Copyright : (c) Harvard University 2009+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C (+ module Language.C.Parser,+ module Language.C.Pretty,+ module Language.C.Syntax+ ) where++import Language.C.Parser+import Language.C.Pretty+import Language.C.Syntax
+ Language/C/Parser.hs view
@@ -0,0 +1,62 @@+-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Parser+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Parser (+ module Language.C.Parser.Lexer,+ module Language.C.Parser.Monad,+ module Language.C.Parser.Parser,+ parse+ ) where++import Control.Exception++import qualified Data.ByteString.Char8 as B+import Data.Loc++import Language.C.Parser.Lexer+import Language.C.Parser.Parser+import Language.C.Parser.Monad+import Language.C.Syntax++parse :: [Extensions]+ -> [String]+ -> ParseContext+ -> P a+ -> B.ByteString+ -> Pos+ -> Either SomeException a+parse exts typnames ctx p bs pos =+ evalP p (emptyPState exts typnames ctx bs pos)
+ Language/C/Parser/Lexer.x view
@@ -0,0 +1,543 @@+{+{-# OPTIONS -w #-}+{-# LANGUAGE CPP #-}++-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Parser.Lexer+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Parser.Lexer (+ lexToken+ ) where++import Control.Monad (when)+import Control.Monad.Error+import Control.Monad.Exception+import Control.Monad.Identity+import Control.Monad.State+import Control.Monad.Trans+import qualified Data.ByteString.Char8 as B+import Data.Char (isAlphaNum,+ isDigit,+ isOctDigit,+ isHexDigit,+ isLower,+ isSpace,+ chr,+ toLower)+import Data.List (foldl', intersperse)+import Data.Loc+import qualified Data.Map as Map+import Data.Ratio ((%))+import qualified Data.Set as Set+import Data.Symbol+import Data.Maybe (fromMaybe)+import Text.PrettyPrint.Mainland++import qualified Language.C.Syntax as C+import Language.C.Parser.Monad+import Language.C.Parser.Tokens+}++$nondigit = [a-z A-Z \_]+$digit = [0-9]+$nonzerodigit = [1-9]+$octalDigit = [0-7]+$hexadecimalDigit = [0-9A-Fa-f]++@fractionalConstant = $digit* "." $digit++ | $digit+ "."+@exponentPart = [eE] [\+\-]? $digit+++@floatingSuffix = [fF]+ | [lL]++@floatingConstant = @fractionalConstant @exponentPart? @floatingSuffix?+ | $digit+ @exponentPart @floatingSuffix?++@decimalConstant = $nonzerodigit $digit*+@octalConstant = "0" $octalDigit*+@hexadecimalConstant = "0" [xX] $hexadecimalDigit+++@integerSuffix = [uU] [lL]?+ | [lL] [uU]?+ | [lL] [lL] [uU]?+ | [uU] [lL] [lL]++$whitechar = [\ \t\n\r\f\v]++c :-++<qq> {+ "typename" / { allowAnti } { token Ttypename }++ "$id:" / { allowAnti } { lexAnti Tanti_id }+ "$int:" / { allowAnti } { lexAnti Tanti_int }+ "$uint:" / { allowAnti } { lexAnti Tanti_uint }+ "$lint:" / { allowAnti } { lexAnti Tanti_lint }+ "$ulint:" / { allowAnti } { lexAnti Tanti_ulint }+ "$float:" / { allowAnti } { lexAnti Tanti_float }+ "$double:" / { allowAnti } { lexAnti Tanti_double }+ "$ldouble:" / { allowAnti } { lexAnti Tanti_long_double }+ "$char:" / { allowAnti } { lexAnti Tanti_char }+ "$string:" / { allowAnti } { lexAnti Tanti_string }+ "$exp:" / { allowAnti } { lexAnti Tanti_exp }+ "$func:" / { allowAnti } { lexAnti Tanti_func }+ "$args:" / { allowAnti } { lexAnti Tanti_args }+ "$decl:" / { allowAnti } { lexAnti Tanti_decl }+ "$decls:" / { allowAnti } { lexAnti Tanti_decls }+ "$sdecl:" / { allowAnti } { lexAnti Tanti_sdecl }+ "$sdecls:" / { allowAnti } { lexAnti Tanti_sdecls }+ "$enum:" / { allowAnti } { lexAnti Tanti_enum }+ "$enums:" / { allowAnti } { lexAnti Tanti_enums }+ "$esc:" / { allowAnti } { lexAnti Tanti_esc }+ "$edecl:" / { allowAnti } { lexAnti Tanti_edecl }+ "$edecls:" / { allowAnti } { lexAnti Tanti_edecls }+ "$item:" / { allowAnti } { lexAnti Tanti_item }+ "$items:" / { allowAnti } { lexAnti Tanti_items }+ "$stm:" / { allowAnti } { lexAnti Tanti_stm }+ "$stms:" / { allowAnti } { lexAnti Tanti_stms }+ "$ty:" / { allowAnti } { lexAnti Tanti_type }+ "$spec:" / { allowAnti } { lexAnti Tanti_spec }+ "$param:" / { allowAnti } { lexAnti Tanti_param }+ "$params:" / { allowAnti } { lexAnti Tanti_params }+ "$" / { allowAnti } { lexAnti Tanti_exp }+}++<0, qq> {+ ^ "#line" $whitechar+ $digit+ $whitechar+ \" [^\"]* \" .* { setLineFromPragma }+ ^ "#" $whitechar+ $digit+ $whitechar+ \" [^\"]* \" .* { setLineFromPragma }++ "//" .* ;+ "/*" ([^\*]|[\r\n]|("*"+([^\*\/]|[\r\n])))* "*"+ "/" ;++ ^ "#" .* ;+ $whitechar+ ;+ "__extension__" ;++ $nondigit ($nondigit | $digit)* { identifier }++ @floatingConstant { lexFloat }+ @decimalConstant @integerSuffix? { lexInteger 0 decimal }+ @octalConstant @integerSuffix? { lexInteger 1 octal }+ @hexadecimalConstant @integerSuffix? { lexInteger 2 hexadecimal }++ \' { lexCharTok }+ \" { lexStringTok }++ "(" { token Tlparen }+ ")" { token Trparen }+ "[" { token Tlbrack }+ "]" { token Trbrack }+ "{" { token Tlbrace }+ "}" { token Trbrace }+ "," { token Tcomma }+ ";" { token Tsemi }+ ":" { token Tcolon }+ "?" { token Tquestion }+ "." { token Tdot }+ "->" { token Tarrow }+ "..." { token Tellipses }++ "+" { token Tplus }+ "-" { token Tminus }+ "*" { token Tstar }+ "/" { token Tdiv }+ "%" { token Tmod }+ "~" { token Tnot }+ "&" { token Tand }+ "|" { token Tor }+ "^" { token Txor }+ "<<" { token Tlsh }+ ">>" { token Trsh }+ "++" { token Tinc }+ "--" { token Tdec }++ "!" { token Tlnot }+ "&&" { token Tland }+ "||" { token Tlor }++ "==" { token Teq }+ "!=" { token Tne }+ "<" { token Tlt }+ ">" { token Tgt }+ "<=" { token Tle }+ ">=" { token Tge }++ "=" { token Tassign }+ "+=" { token Tadd_assign }+ "-=" { token Tsub_assign }+ "*=" { token Tmul_assign }+ "/=" { token Tdiv_assign }+ "%=" { token Tmod_assign }+ "&=" { token Tand_assign }+ "|=" { token Tor_assign }+ "^=" { token Txor_assign }+ "<<=" { token Tlsh_assign }+ ">>=" { token Trsh_assign }++ "<<<" / { ifExtension cudaExts }+ { token T3lt }++ ">>>" / { ifExtension cudaExts }+ { token T3gt }+}++{+charEscapes :: [(Char, Char)]+charEscapes = [('n', '\n'),+ ('t', '\t'),+ ('v', '\v'),+ ('b', '\b'),+ ('r', '\r'),+ ('f', '\f'),+ ('a', '\a'),+ ('\\', '\\'),+ ('?', '?'),+ ('\'', '\''),+ ('\"', '\"')+ ]++type Action = Pos -> B.ByteString -> Int -> P (L Token)++setLineFromPragma :: Action+setLineFromPragma pos buf len = do+ setPos pos'+ lexToken+ where+ (_ : l : ws) = (words . B.unpack . B.take len) buf+ line = read l - 1+ filename = (takeWhile (/= '\"') . drop 1 . concat . intersperse " ") ws++ pos' :: Pos+ pos' = Pos (intern filename) line 1 (posCoff pos)++locateTok :: Pos -> Token -> P (L Token)+locateTok end tok = do+ start <- getLastPos+ setLastPos end+ return $ L (Loc start end) tok++token :: Token -> Action+token tok pos buf len =+ locateTok pos tok++identifier :: Action+identifier pos buf len =+ case Map.lookup kw keywordMap of+ Nothing -> nonKeyword+ Just (tok, Nothing) -> keyword tok+ Just (tok, Just i) -> do isKw <- useExts i+ if isKw then keyword tok else nonKeyword+ where+ kw = (B.unpack . B.take len) buf++ keyword tok = locateTok pos tok++ nonKeyword = do+ test <- isTypedef kw+ if test+ then locateTok pos (Tnamed kw)+ else locateTok pos (Tidentifier kw)++lexAnti ::(String -> Token) -> Action+lexAnti antiTok pos buf len = do+ c <- alexGetCharOrFail+ s <- case c of+ '(' -> lexExpression 0 ""+ _ | isIdStartChar c -> lexIdChars [c]+ | otherwise -> illegalCharacterLiteral pos+ end <- getPos+ locateTok end (antiTok s)+ where+ lexIdChars :: String -> P String+ lexIdChars s = do+ inp <- getInput+ maybe_c <- alexMaybeGetChar+ case maybe_c of+ Nothing -> return (reverse s)+ Just c | isIdChar c -> lexIdChars (c : s)+ | otherwise -> setInput inp >> return (reverse s)++ lexExpression :: Int -> String -> P String+ lexExpression depth s = do+ inp <- getInput+ maybe_c <- alexMaybeGetChar+ case maybe_c of+ Nothing -> return (reverse s)+ Just '(' -> lexExpression (depth+1) ('(' : s)+ Just ')' | depth == 0 -> return (reverse s)+ | otherwise -> lexExpression (depth-1) (')' : s)+ Just c -> lexExpression depth (c : s)++ isIdStartChar :: Char -> Bool+ isIdStartChar '_' = True+ isIdStartChar c = isLower c++ isIdChar :: Char -> Bool+ isIdChar '_' = True+ isIdChar '\'' = True+ isIdChar c = isAlphaNum c++lexCharTok :: Action+lexCharTok pos buf len = do+ c <- alexGetCharOrFail+ case c of+ '\'' -> emptyCharacterLiteral pos+ '\\' -> do c <- lexEscape+ quote <- alexGetCharOrFail+ when (quote /= '\'') $+ illegalCharacterLiteral pos+ end <- getPos+ raw <- liftM ('\'' :) (getBuffRange pos end)+ locateTok end (TcharConst (raw, c))+ _ -> do quote <- alexGetCharOrFail+ when (quote /= '\'') $+ illegalCharacterLiteral pos+ end <- getPos+ raw <- liftM ('\'' :) (getBuffRange pos end)+ locateTok end (TcharConst (raw, c))++lexStringTok :: Action+lexStringTok pos buf len = do+ s <- lexString ""+ end <- getPos+ raw <- liftM ('"' :) (getBuffRange pos end)+ locateTok end (TstringConst (raw, s))+ where+ lexString :: String -> P String+ lexString s = do+ c <- alexGetCharOrFail+ case c of+ '"' -> return (reverse s)+ '\\' -> do c' <- lexEscape+ lexString (c' : s)+ _ -> lexString (c : s)++lexEscape :: P Char+lexEscape = do+ inp <- getInput+ c <- alexGetCharOrFail+ case c of+ 'x' -> do i <- checkedReadNum isHexDigit 16 hexDigit+ return $ chr i+ n | isDigit n ->+ do setInput inp+ i <- checkedReadNum isOctDigit 8 octDigit+ return $ chr i+ c -> case lookup c charEscapes of+ Nothing -> return c+ Just c' -> return c'++type Radix = (Integer, Char -> Int)++decDigit :: Char -> Int+decDigit c | c >= '0' && c <= '9' = ord c - ord '0'+ | otherwise = error "error in decimal constant"++octDigit :: Char -> Int+octDigit c | c >= '0' && c <= '7' = ord c - ord '0'+ | otherwise = error "error in octal constant"++hexDigit :: Char -> Int+hexDigit c | c >= 'a' && c <= 'f' = ord c - ord 'a'+ | c >= 'A' && c <= 'F' = ord c - ord 'A'+ | c >= '0' && c <= '9' = ord c - ord '0'+ | otherwise = error "error in hexadecimal constant"++decimal :: Radix+decimal = (10, decDigit)++octal :: Radix+octal = (8, octDigit)++hexadecimal :: Radix+hexadecimal = (16, hexDigit)++readInteger :: Radix -> ReadS Integer+readInteger (radix, charToInt) =+ go 0+ where+ go :: Integer -> ReadS Integer+ go x [] = return (x, "")+ go x (c : cs) | isDigit c = go (x * radix + toInteger (charToInt c)) cs+ | otherwise = return (x, c : cs)++readRational :: ReadS Rational+readRational s = do+ (n, d, t) <- readFix s+ (x, u) <- readExponent t+ return ((n % 1) * 10^^(x - toInteger d), t)+ where+ readFix :: String -> [(Integer, Int, String)]+ readFix s =+ return (read (i ++ f), length f, u)+ where+ (i, t) = span isDigit s+ (f, u) = case t of+ '.' : u -> span isDigit u+ _ -> ("", t)++ readExponent :: ReadS Integer+ readExponent "" = return (0, "")+ readExponent (e : s) | e `elem` "eE" = go s+ | otherwise = return (0, s)+ where+ go :: ReadS Integer+ go ('+' : s) = readDecimal s+ go ('-' : s) = do (x, t) <- readDecimal s+ return (-x, t)+ go s = readDecimal s++ readDecimal :: ReadS Integer+ readDecimal = readInteger decimal++lexInteger :: Int+ -> Radix+ -> Action+lexInteger ndrop radix pos buf len =+ case i of+ [n] -> locateTok pos (toToken n)+ _ -> fail "bad parse for integer"+ where+ num :: String+ num = (takeWhile isDigit . drop ndrop) s++ suffix :: String+ suffix = (map toLower . takeWhile (not . isDigit) . reverse) s++ s :: String+ s = (B.unpack . B.take len) buf++ i :: [Integer]+ i = do (n, _) <- readInteger radix s+ return n++ toToken :: Integer -> Token+ toToken n =+ case numElls of+ 0 -> TintConst (s, isUnsigned, n)+ 1 -> TlongIntConst (s, isUnsigned, n)+ 2 -> TlongLongIntConst (s, isUnsigned, n)+ where+ numElls :: Int+ numElls = (length . filter (== 'l')) suffix++ isUnsigned :: C.Signed+ isUnsigned = if 'u' `elem` suffix then C.Unsigned else C.Signed++lexFloat :: Action+lexFloat pos buf len =+ case i of+ [n] -> locateTok pos (toToken n)+ _ -> fail "bad parse for integer"+ where+ s :: String+ s = (B.unpack . B.take len) buf++ prefix :: String+ prefix = takeWhile (not . isSuffix) s++ suffix :: String+ suffix = (map toLower . takeWhile isSuffix . reverse) s++ isSuffix :: Char -> Bool+ isSuffix = (`elem` ['l', 'L', 'f', 'F'])++ i :: [Rational]+ i = do (n, _) <- readRational s+ return n++ toToken :: Rational -> Token+ toToken n =+ case suffix of+ "" -> TdoubleConst (s, n)+ "f" -> TfloatConst (s, n)+ "l" -> TlongDoubleConst (s, n)++checkedReadNum :: (Char -> Bool) -> Int -> (Char -> Int) -> P Int+checkedReadNum isDigit base conv = do+ c <- alexGetCharOrFail+ when (not $ isDigit c) $+ getPos >>= illegalNumericalLiteral+ readNum isDigit base conv+ where+ readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> P Int+ readNum isDigit base conv = read 0+ where+ read :: Int -> P Int+ read i = do+ inp <- getInput+ c <- alexGetCharOrFail+ if isDigit c+ then read (i*base + conv c)+ else setInput inp >> return i++lexToken :: P (L Token)+lexToken = do+ inp@(AlexInput pos buf off) <- getInput+ sc <- getLexState+ st <- get+ case alexScanUser st inp sc of+ AlexEOF -> return $ L (Loc pos pos) Teof+ AlexError (AlexInput pos2 _ _) ->+ lexerError pos2 ((text . B.unpack . B.take (min 80 (B.length rest))) rest)+ where+ rest = B.drop off buf+ AlexSkip inp2 _ -> do+ setInput inp2+ pos <- getPos+ setLastPos pos+ lexToken+ AlexToken inp2@(AlexInput end _ _) len t -> do+ setInput inp2+ t end (B.drop off buf) len++emptyCharacterLiteral :: Pos -> P a+emptyCharacterLiteral pos =+ throw $ ParserException (getLoc pos) (text "empty character literal")++illegalCharacterLiteral :: Pos -> P a+illegalCharacterLiteral pos =+ throw $ ParserException (getLoc pos) (text "illegal character literal")++illegalNumericalLiteral :: Pos -> P a+illegalNumericalLiteral pos =+ throw $ ParserException (getLoc pos) (text "illegal numerical literal")++lexerError :: Pos -> Doc -> P a+lexerError pos s =+ throw $ ParserException (getLoc pos) (text "lexer error on" <+> squotes s)+}
+ Language/C/Parser/Monad.hs view
@@ -0,0 +1,313 @@+-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.+--+-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Parser.Monad+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}++module Language.C.Parser.Monad (+ AlexInput(..),+ alexGetChar,+ alexMaybeGetChar,+ alexGetCharOrFail,+ alexInputPrevChar,+ allowAnti,+ ifExtension,++ ParserException(..),+ ParseContext(..),+ PState,+ emptyPState,++ P,+ runP,+ evalP,++ failAt,++ getBuffer,+ setBuffer,+ getBuffRange,+ getLastPos,+ setLastPos,+ getPos,+ setPos,+ pushLexState,+ popLexState,+ getLexState,+ getParseContext,+ setParseContext,+ getInput,+ setInput,++ addTypedef,+ addVariable,+ isTypedef,++ pushScope,+ popScope,++ gccExts,+ cudaExts,++ useExts,+ useGccExts,+ useCUDAExts+ ) where++import Control.Monad.Exception+import Control.Monad.Identity+import Control.Monad.State+import Data.Bits+import qualified Data.ByteString.Char8 as B+import Data.List (foldl')+import Data.Loc+import qualified Data.Set as Set+import Data.Typeable (Typeable)+import Text.PrettyPrint.Mainland++import Language.C.Parser.Tokens+import Language.C.Syntax++data AlexInput = AlexInput {-#UNPACK#-} !Pos+ {-#UNPACK#-} !B.ByteString+ {-#UNPACK#-} !Int++alexGetChar :: AlexInput -> Maybe (Char, AlexInput)+alexGetChar (AlexInput pos buf off)+ | off < B.length buf = c `seq` pos' `seq` off' `seq`+ Just (c, AlexInput pos' buf off')+ | otherwise = Nothing+ where+ c = B.index buf off+ pos' = advancePos pos c+ off' = off + 1++alexMaybeGetChar :: P (Maybe Char)+alexMaybeGetChar = do+ inp <- getInput+ case alexGetChar inp of+ Nothing -> return Nothing+ Just (c, inp') -> setInput inp' >> return (Just c)++alexGetCharOrFail :: P Char+alexGetCharOrFail = do+ inp <- getInput+ case alexGetChar inp of+ Nothing -> fail "unexpected end of file"+ Just (c, inp') -> setInput inp' >> return c++alexInputPrevChar :: AlexInput -> Char+alexInputPrevChar (AlexInput _ _ 0) = '\n'+alexInputPrevChar (AlexInput _ buf off) = B.index buf (off - 1)++-- | The components of an 'AlexPredicate' are the predicate state, input stream+-- before the token, length of the token, input stream after the token.+type AlexPredicate = PState+ -> AlexInput+ -> Int+ -> AlexInput+ -> Bool++allowAnti :: AlexPredicate+allowAnti (PState { context = ParseQuasiQuote }) _ _ _ = True+allowAnti _ _ _ _ = False++ifExtension :: ExtensionsInt -> AlexPredicate+ifExtension i s _ _ _ = extensions s .&. i /= 0++data ParserException = ParserException Loc Doc+ deriving (Typeable)++instance Exception ParserException where++instance Show ParserException where+ show (ParserException loc msg) =+ show $ nest 4 $ ppr loc <> text ":" </> msg++data ParseContext = ParseDirect+ | ParseQuasiQuote++data PState = PState+ { buf :: !B.ByteString -- ^ Buffer we're parsing+ , off :: !Int -- ^ Current offset in the buffer+ , lastPos :: !Pos -- ^ End position of last token parsed+ , pos :: !Pos -- ^ Current source code position+ , lexState :: ![Int]+ , context :: !ParseContext+ , extensions :: !ExtensionsInt++ , typedefs :: !(Set.Set String)+ , scopes :: [Set.Set String]+ }++emptyPState :: [Extensions]+ -> [String]+ -> ParseContext+ -> B.ByteString+ -> Pos+ -> PState+emptyPState exts typnames ctx bs pos = PState+ { buf = bs+ , off = 0+ , lastPos = pos+ , pos = pos+ , lexState = [sc]+ , context = ctx+ , extensions = foldl' setBit 0 (map fromEnum exts)++ , typedefs = Set.fromList typnames+ , scopes = []+ }+ where+ sc :: Int+ sc = case ctx of+ ParseDirect -> 0+ ParseQuasiQuote -> 1 {- qq lexer state -}++newtype P a = P { unP :: StateT PState (ExceptionT Identity) a }+ deriving (MonadException,+ MonadState PState)++instance Monad P where+ m >>= f = P $ unP m >>= unP . f+ m1 >> m2 = P $ unP m1 >> unP m2+ return = P . return+ fail msg = do pos <- getPos+ throw $ ParserException (getLoc pos) (text msg)++runP :: P a -> PState -> Either SomeException (a, PState)+runP m = runIdentity . runExceptionT . runStateT (unP m)++evalP :: P a -> PState -> Either SomeException a+evalP m = runIdentity . runExceptionT . evalStateT (unP m)++failAt :: Loc -> String -> P a+failAt loc msg =+ throw $ ParserException loc (text msg)++getBuffer :: P B.ByteString+getBuffer = gets buf++setBuffer :: B.ByteString -> P ()+setBuffer buf = modify $ \s ->+ s { buf = buf }++getBuffRange :: Pos -> Pos -> P String+getBuffRange (Pos _ _ _ start) (Pos _ _ _ end) = do+ b <- gets buf+ return $ (B.unpack . B.take (end - start) . B.drop start) b++getLastPos :: P Pos+getLastPos = gets lastPos++setLastPos :: Pos -> P ()+setLastPos pos = modify $ \s ->+ s { lastPos = pos }++getPos :: P Pos+getPos = gets pos++setPos :: Pos -> P ()+setPos pos = modify $ \s ->+ s { pos = pos }++pushLexState :: Int -> P ()+pushLexState ls = modify $ \s ->+ s { lexState = ls : lexState s }++popLexState :: P Int+popLexState = do+ ls <- getLexState+ modify $ \s ->+ s { lexState = tail (lexState s) }+ return ls++getLexState :: P Int+getLexState = gets (head . lexState)++getParseContext :: P ParseContext+getParseContext = gets context++setParseContext :: ParseContext -> P ()+setParseContext ctx = modify $ \s ->+ s { context = ctx }++getInput :: P AlexInput+getInput = gets $ \s ->+ AlexInput (pos s) (buf s) (off s)++setInput :: AlexInput -> P ()+setInput (AlexInput p b o) = modify $ \s ->+ s { buf = b, off = o, pos = p }++addTypedef :: String -> P ()+addTypedef id = modify $ \s ->+ s { typedefs = Set.insert id (typedefs s) }++addVariable :: String -> P ()+addVariable id = modify $ \s ->+ s { typedefs = Set.delete id (typedefs s) }++isTypedef :: String -> P Bool+isTypedef id = gets $ \s ->+ Set.member id (typedefs s)++pushScope :: P ()+pushScope = modify $ \s ->+ s { scopes = typedefs s : scopes s }++popScope :: P ()+popScope = modify $ \s ->+ s { scopes = (tail . scopes) s+ , typedefs = (head . scopes) s+ }++useExts :: ExtensionsInt -> P Bool+useExts ext = gets $ \s ->+ extensions s .&. ext /= 0++gccExts :: ExtensionsInt+gccExts = (bit . fromEnum) Gcc++cudaExts :: ExtensionsInt+cudaExts = (bit . fromEnum) CUDA++useGccExts :: P Bool+useGccExts = useExts gccExts++useCUDAExts :: P Bool+useCUDAExts = useExts cudaExts
+ Language/C/Parser/Parser.y view
@@ -0,0 +1,2185 @@+{+{-# OPTIONS -w #-}++-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Parser.Parser+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Parser.Parser where++import Control.Monad (forM_,+ when)+import Control.Monad.Exception+import Data.List (intersperse)+import Data.Loc+import Data.Maybe (catMaybes)+import Text.PrettyPrint.Mainland++import Language.C.Parser.Lexer+import Language.C.Parser.Monad+import qualified Language.C.Parser.Tokens as T+import Language.C.Pretty+import Language.C.Syntax+import qualified Language.C.Syntax as C+}++%token+ CHAR { L _ (T.TcharConst _) }+ STRING { L _ (T.TstringConst _) }+ INT { L _ (T.TintConst _) }+ LONG { L _ (T.TlongIntConst _) }+ LONG_LONG { L _ (T.TlongLongIntConst _) }+ FLOAT { L _ (T.TfloatConst _) }+ DOUBLE { L _ (T.TdoubleConst _) }+ LONG_DOUBLE { L _ (T.TlongDoubleConst _) }+ ID { L _ (T.Tidentifier _) }+ NAMED { L _ (T.Tnamed _) }++ '(' { L _ T.Tlparen }+ ')' { L _ T.Trparen }+ '[' { L _ T.Tlbrack }+ ']' { L _ T.Trbrack }+ '{' { L _ T.Tlbrace }+ '}' { L _ T.Trbrace }+ ',' { L _ T.Tcomma }+ ';' { L _ T.Tsemi }+ ':' { L _ T.Tcolon }+ '?' { L _ T.Tquestion }+ '.' { L _ T.Tdot }+ '->' { L _ T.Tarrow }+ '...' { L _ T.Tellipses }++ '+' { L _ T.Tplus }+ '-' { L _ T.Tminus }+ '*' { L _ T.Tstar }+ '/' { L _ T.Tdiv }+ '%' { L _ T.Tmod }+ '~' { L _ T.Tnot }+ '&' { L _ T.Tand }+ '|' { L _ T.Tor }+ '^' { L _ T.Txor }+ '<<' { L _ T.Tlsh }+ '>>' { L _ T.Trsh }+ '++' { L _ T.Tinc }+ '--' { L _ T.Tdec }++ '!' { L _ T.Tlnot }+ '&&' { L _ T.Tland }+ '||' { L _ T.Tlor }++ '==' { L _ T.Teq }+ '!=' { L _ T.Tne }+ '<' { L _ T.Tlt }+ '>' { L _ T.Tgt }+ '<=' { L _ T.Tle }+ '>=' { L _ T.Tge }++ '=' { L _ T.Tassign }+ '+=' { L _ T.Tadd_assign }+ '-=' { L _ T.Tsub_assign }+ '*=' { L _ T.Tmul_assign }+ '/=' { L _ T.Tdiv_assign }+ '%=' { L _ T.Tmod_assign }+ '<<=' { L _ T.Tlsh_assign }+ '>>=' { L _ T.Trsh_assign }+ '&=' { L _ T.Tand_assign }+ '|=' { L _ T.Tor_assign }+ '^=' { L _ T.Txor_assign }++ 'auto' { L _ T.Tauto }+ 'break' { L _ T.Tbreak }+ 'case' { L _ T.Tcase }+ 'char' { L _ T.Tchar }+ 'const' { L _ T.Tconst }+ 'continue' { L _ T.Tcontinue }+ 'default' { L _ T.Tdefault }+ 'do' { L _ T.Tdo }+ 'double' { L _ T.Tdouble }+ 'else' { L _ T.Telse }+ 'enum' { L _ T.Tenum }+ 'extern' { L _ T.Textern }+ 'float' { L _ T.Tfloat }+ 'for' { L _ T.Tfor }+ 'goto' { L _ T.Tgoto }+ 'if' { L _ T.Tif }+ 'inline' { L _ T.Tinline }+ 'int' { L _ T.Tint }+ 'long' { L _ T.Tlong }+ 'register' { L _ T.Tregister }+ 'restrict' { L _ T.Trestrict }+ 'return' { L _ T.Treturn }+ 'short' { L _ T.Tshort }+ 'signed' { L _ T.Tsigned }+ 'sizeof' { L _ T.Tsizeof }+ 'static' { L _ T.Tstatic }+ 'struct' { L _ T.Tstruct }+ 'switch' { L _ T.Tswitch }+ 'typedef' { L _ T.Ttypedef }+ 'union' { L _ T.Tunion }+ 'unsigned' { L _ T.Tunsigned }+ 'void' { L _ T.Tvoid }+ 'volatile' { L _ T.Tvolatile }+ 'while' { L _ T.Twhile }+ '_Bool' { L _ T.TBool }+ '_Complex' { L _ T.TComplex }+ '_Imaginary' { L _ T.TImaginary }++ '__asm__' { L _ T.Tasm }+ '__attribute__' { L _ T.Tattribute }+ '__extension__' { L _ T.Textension }+ '__builtin_va_arg' { L _ T.Tbuiltin_va_arg }+ '__builtin_va_list' { L _ T.Tbuiltin_va_list }+ '__typeof__' { L _ T.Ttypeof }++ '<<<' { L _ T.T3lt }+ '>>>' { L _ T.T3gt }+ '__device__' { L _ T.Tdevice }+ '__global__' { L _ T.Tglobal }+ '__host__' { L _ T.Thost }+ '__constant__' { L _ T.Tconstant }+ '__shared__' { L _ T.Tshared }+ '__noinline__' { L _ T.Tnoinline }++ 'typename' { L _ T.Ttypename }++ ANTI_ID { L _ (T.Tanti_id _) }+ ANTI_INT { L _ (T.Tanti_int _) }+ ANTI_UINT { L _ (T.Tanti_uint _) }+ ANTI_LINT { L _ (T.Tanti_lint _) }+ ANTI_ULINT { L _ (T.Tanti_ulint _) }+ ANTI_FLOAT { L _ (T.Tanti_float _) }+ ANTI_DOUBLE { L _ (T.Tanti_double _) }+ ANTI_LONG_DOUBLE { L _ (T.Tanti_long_double _) }+ ANTI_CHAR { L _ (T.Tanti_char _) }+ ANTI_STRING { L _ (T.Tanti_string _) }+ ANTI_EXP { L _ (T.Tanti_exp _) }+ ANTI_FUNC { L _ (T.Tanti_func _) }+ ANTI_ARGS { L _ (T.Tanti_args _) }+ ANTI_DECL { L _ (T.Tanti_decl _) }+ ANTI_DECLS { L _ (T.Tanti_decls _) }+ ANTI_SDECL { L _ (T.Tanti_sdecl _) }+ ANTI_SDECLS { L _ (T.Tanti_sdecls _) }+ ANTI_ENUM { L _ (T.Tanti_enum _) }+ ANTI_ENUMS { L _ (T.Tanti_enums _) }+ ANTI_ESC { L _ (T.Tanti_esc _) }+ ANTI_EDECL { L _ (T.Tanti_edecl _) }+ ANTI_EDECLS { L _ (T.Tanti_edecls _) }+ ANTI_ITEM { L _ (T.Tanti_item _) }+ ANTI_ITEMS { L _ (T.Tanti_items _) }+ ANTI_STM { L _ (T.Tanti_stm _) }+ ANTI_STMS { L _ (T.Tanti_stms _) }+ ANTI_SPEC { L _ (T.Tanti_spec _) }+ ANTI_TYPE { L _ (T.Tanti_type _) }+ ANTI_PARAM { L _ (T.Tanti_param _) }+ ANTI_PARAMS { L _ (T.Tanti_params _) }++%expect 1++%monad { P } { >>= } { return }+%lexer { lexer } { L _ T.Teof }+%tokentype { (L T.Token) }+%error { happyError }++%name parseExp expression++%name parseEdecl external_declaration+%name parseDecl declaration+%name parseStructDecl struct_declaration+%name parseEnum enumerator++%name parseType type_declaration+%name parseParam parameter_declaration+%name parseInit initializer++%name parseStm statement++%name parseUnit translation_unit+%name parseFunc function_definition++%right NAMED+%%++{------------------------------------------------------------------------------+ -+ - Identifiers+ -+ ------------------------------------------------------------------------------}++identifier :: { Id }+identifier :+ ID { Id (getID $1) (locOf $1) }+ | ANTI_ID { AntiId (getANTI_ID $1) (locOf $1) }++identifier_or_typedef :: { Id }+identifier_or_typedef :+ identifier { $1 }+ | NAMED { Id (getNAMED $1) (locOf $1) }++{------------------------------------------------------------------------------+ -+ - Constants+ -+ ------------------------------------------------------------------------------}++constant :: { Const }+constant :+ INT { let (s, sign, n) = getINT $1+ in+ IntConst s sign n (locOf $1)+ }+ | LONG { let (s, sign, n) = getLONG $1+ in+ LongIntConst s sign n (locOf $1)+ }+ | LONG_LONG { let (s, sign, n) = getLONG_LONG $1+ in+ LongLongIntConst s sign n (locOf $1)+ }+ | FLOAT { let (s, n) = getFLOAT $1+ in+ FloatConst s n (locOf $1)+ }+ | DOUBLE { let (s, n) = getDOUBLE $1+ in+ DoubleConst s n (locOf $1)+ }+ | LONG_DOUBLE { let (s, n) = getLONG_DOUBLE $1+ in+ LongDoubleConst s n (locOf $1)+ }+ | CHAR { let (s, c) = getCHAR $1+ in+ CharConst s c (locOf $1)+ }+ | ANTI_INT { AntiInt (getANTI_INT $1) (locOf $1) }+ | ANTI_UINT { AntiUInt (getANTI_UINT $1) (locOf $1) }+ | ANTI_LINT { AntiLInt (getANTI_LINT $1) (locOf $1) }+ | ANTI_ULINT { AntiULInt (getANTI_ULINT $1) (locOf $1) }+ | ANTI_FLOAT { AntiFloat (getANTI_FLOAT $1) (locOf $1) }+ | ANTI_DOUBLE { AntiDouble (getANTI_DOUBLE $1) (locOf $1) }+ | ANTI_LONG_DOUBLE { AntiLongDouble (getANTI_LONG_DOUBLE $1) (locOf $1) }+ | ANTI_CHAR { AntiChar (getANTI_CHAR $1) (locOf $1) }+ | ANTI_STRING { AntiString (getANTI_STRING $1) (locOf $1) }+++{------------------------------------------------------------------------------+ -+ - Expressions+ -+ ------------------------------------------------------------------------------}++primary_expression :: { Exp }+primary_expression :+ identifier+ { Var $1 (locOf $1) }+ | constant+ { Const $1 (locOf $1) }+ | string_constant+ { let { ss = rev $1+ ; loc = locOf ss+ ; raw = map (fst . unLoc) ss+ ; s = (concat . intersperse " " . map (snd . unLoc)) ss+ }+ in+ Const (StringConst raw s loc) loc+ }+ | '(' expression ')'+ { $2 }+ | '(' expression error+ {% unclosed ($1 <--> $2) "(" }+ | '(' compound_statement ')'+ { let Block items _ = $2+ in+ StmExpr items ($1 <--> $3)+ }+ | ANTI_EXP+ { AntiExp (getANTI_EXP $1) (locOf $1) }++string_constant :: { RevList (L (String, String)) }+string_constant :+ STRING { rsingleton (L (getLoc $1) (getSTRING $1)) }+ {- Extension: GCC -}+ | string_constant STRING { rcons (L (getLoc $2) (getSTRING $2)) $1 }++postfix_expression :: { Exp }+postfix_expression :+ primary_expression+ { $1 }+ | postfix_expression '[' error+ {% unclosed (locOf $1) "[" }+ | postfix_expression '[' expression ']'+ { Index $1 $3 ($1 <--> $4) }++ | postfix_expression '(' error+ {% unclosed (locOf $2) "(" }+ | postfix_expression '(' ')'+ { FnCall $1 [] ($1 <--> $3) }+ | postfix_expression '(' argument_expression_list error+ {% unclosed ($2 <--> rev $3) "(" }+ | postfix_expression '(' argument_expression_list ')'+ { FnCall $1 (rev $3) ($1 <--> $4) }++ | postfix_expression '<<<' execution_configuration error+ {% unclosed ($2 <--> $3) "<<<" }+ | postfix_expression '<<<' execution_configuration '>>>' '(' ')'+ { CudaCall $1 $3 [] ($1 <--> $6) }+ | postfix_expression '<<<' execution_configuration '>>>'+ '(' argument_expression_list error+ {% unclosed ($5 <--> rev $6) "(" }+ | postfix_expression '<<<' execution_configuration '>>>'+ '(' argument_expression_list ')'+ { CudaCall $1 $3 (rev $6) ($1 <--> $7) }++ | postfix_expression '.' identifier_or_typedef+ { Member $1 $3 ($1 <--> $3) }+ | postfix_expression '->' identifier_or_typedef+ { PtrMember $1 $3 ($1 <--> $3) }+ | postfix_expression '++'+ { PostInc $1 ($1 <--> $2) }+ | postfix_expression '--'+ { PostDec $1 ($1 <--> $2) }+ | '(' type_name ')' '{' initializer_list '}'+ { CompoundLit ($2 :: Type) (rev $5) ($1 <--> $6) }+ | '(' type_name ')' '{' initializer_list ',' '}'+ { CompoundLit $2 (rev $5) ($1 <--> $7) }+ {- Extension: GCC -}+ | '__builtin_va_arg' '(' assignment_expression ',' type_declaration ')'+ { BuiltinVaArg $3 $5 ($1 <--> $6) }++{- Extension: CUDA -}+execution_configuration :: { ExeConfig }+execution_configuration :+ argument_expression_list+ {%do { let args = rev $1+ ; when (length args < 2 || length args > 4) $+ badExecutionContext (getLoc args) args+ ; return $+ case args of+ [gridDim, blockDim] ->+ ExeConfig gridDim blockDim+ Nothing Nothing+ (locOf args)+ [gridDim, blockDim, sharedSize] ->+ ExeConfig gridDim blockDim+ (Just sharedSize) Nothing+ (locOf args)+ [gridDim, blockDim, sharedSize, exeStream] ->+ ExeConfig gridDim blockDim+ (Just sharedSize) (Just exeStream)+ (locOf args)+ }+ }++argument_expression_list :: { RevList Exp }+argument_expression_list :+ assignment_expression+ { rsingleton $1 }+ | ANTI_ARGS+ { rsingleton (AntiArgs (getANTI_ARGS $1) (locOf $1)) }+ | argument_expression_list ',' assignment_expression+ { rcons $3 $1}+ | argument_expression_list ',' ANTI_ARGS+ { rcons (AntiArgs (getANTI_ARGS $3) (locOf $3)) $1 }++unary_expression :: { Exp }+unary_expression :+ postfix_expression { $1 }+ | '++' unary_expression { PreInc $2 ($1 <--> $2) }+ | '--' unary_expression { PreDec $2 ($1 <--> $2) }+ | '&' cast_expression { UnOp AddrOf $2 ($1 <--> $2) }+ | '*' cast_expression { UnOp Deref $2 ($1 <--> $2) }+ | '+' cast_expression { UnOp Positive $2 ($1 <--> $2) }+ | '-' cast_expression { UnOp Negate $2 ($1 <--> $2) }+ | '~' cast_expression { UnOp Not $2 ($1 <--> $2) }+ | '!' cast_expression { UnOp Lnot $2 ($1 <--> $2) }+ | 'sizeof' unary_expression { SizeofExp $2 ($1 <--> $2) }+ | 'sizeof' '(' type_name ')' { SizeofType $3 ($1 <--> $4) }+ | 'sizeof' '(' type_name error {% unclosed ($2 <--> $3) "(" }++cast_expression :: { Exp }+cast_expression :+ unary_expression { $1 }+ | '(' type_name ')' cast_expression { Cast $2 $4 ($1 <--> $4) }+ | '(' type_name error {% unclosed ($1 <--> $2) "(" }++multiplicative_expression :: { Exp }+multiplicative_expression :+ cast_expression+ { $1 }+ | multiplicative_expression '*' cast_expression+ { BinOp Mul $1 $3 ($1 <--> $3) }+ | multiplicative_expression '/' cast_expression+ { BinOp Div $1 $3 ($1 <--> $3) }+ | multiplicative_expression '%' cast_expression+ { BinOp Mod $1 $3 ($1 <--> $3) }++additive_expression :: { Exp }+additive_expression :+ multiplicative_expression+ { $1 }+ | additive_expression '+' multiplicative_expression+ { BinOp Add $1 $3 ($1 <--> $3) }+ | additive_expression '-' multiplicative_expression+ { BinOp Sub $1 $3 ($1 <--> $3) }++shift_expression :: { Exp }+shift_expression :+ additive_expression+ { $1 }+ | shift_expression '<<' additive_expression+ { BinOp Lsh $1 $3 ($1 <--> $3) }+ | shift_expression '>>' additive_expression+ { BinOp Rsh $1 $3 ($1 <--> $3) }++relational_expression :: { Exp }+relational_expression :+ shift_expression+ { $1 }+ | relational_expression '<' shift_expression+ { BinOp Lt $1 $3 ($1 <--> $3) }+ | relational_expression '>' shift_expression+ { BinOp Gt $1 $3 ($1 <--> $3) }+ | relational_expression '<=' shift_expression+ { BinOp Le $1 $3 ($1 <--> $3) }+ | relational_expression '>=' shift_expression+ { BinOp Ge $1 $3 ($1 <--> $3) }++equality_expression :: { Exp }+equality_expression :+ relational_expression+ { $1 }+ | equality_expression '==' relational_expression+ { BinOp Eq $1 $3 ($1 <--> $3) }+ | equality_expression '!=' relational_expression+ { BinOp Ne $1 $3 ($1 <--> $3) }++and_expression :: { Exp }+and_expression :+ equality_expression+ { $1 }+ | and_expression '&' equality_expression+ { BinOp And $1 $3 ($1 <--> $3) }++exclusive_or_expression :: { Exp }+exclusive_or_expression :+ and_expression+ { $1 }+ | exclusive_or_expression '^' and_expression+ { BinOp Xor $1 $3 ($1 <--> $3) }++inclusive_or_expression :: { Exp }+inclusive_or_expression :+ exclusive_or_expression+ { $1 }+ | inclusive_or_expression '|' exclusive_or_expression+ { BinOp Or $1 $3 ($1 <--> $3) }++logical_and_expression :: { Exp }+logical_and_expression :+ inclusive_or_expression+ { $1 }+ | logical_and_expression '&&' inclusive_or_expression+ { BinOp Land $1 $3 ($1 <--> $3) }++logical_or_expression :: { Exp }+logical_or_expression :+ logical_and_expression+ { $1 }+ | logical_or_expression '||' logical_and_expression+ { BinOp Lor $1 $3 ($1 <--> $3) }++conditional_expression :: { Exp }+conditional_expression :+ logical_or_expression+ { $1 }+ | logical_or_expression '?' expression ':' conditional_expression+ { Cond $1 $3 $5 ($1 <--> $5) }++assignment_expression :: { Exp }+assignment_expression :+ conditional_expression+ { $1 }+ | unary_expression '=' assignment_expression+ { Assign $1 JustAssign $3 ($1 <--> $3) }+ | unary_expression '*=' assignment_expression+ { Assign $1 MulAssign $3 ($1 <--> $3) }+ | unary_expression '/=' assignment_expression+ { Assign $1 DivAssign $3 ($1 <--> $3) }+ | unary_expression '%=' assignment_expression+ { Assign $1 ModAssign $3 ($1 <--> $3) }+ | unary_expression '+=' assignment_expression+ { Assign $1 AddAssign $3 ($1 <--> $3) }+ | unary_expression '-=' assignment_expression+ { Assign $1 SubAssign $3 ($1 <--> $3) }+ | unary_expression '<<=' assignment_expression+ { Assign $1 LshAssign $3 ($1 <--> $3) }+ | unary_expression '>>=' assignment_expression+ { Assign $1 RshAssign $3 ($1 <--> $3) }+ | unary_expression '&=' assignment_expression+ { Assign $1 AndAssign $3 ($1 <--> $3) }+ | unary_expression '^=' assignment_expression+ { Assign $1 XorAssign $3 ($1 <--> $3) }+ | unary_expression '|=' assignment_expression+ { Assign $1 OrAssign $3 ($1 <--> $3) }++expression :: { Exp }+expression :+ assignment_expression { $1 }+ | expression ',' assignment_expression { Seq $1 $3 ($1 <--> $3) }++maybe_expression :: { Maybe Exp }+maybe_expression:+ {- empty -} { Nothing }+ | expression { Just $1 }++constant_expression :: { Exp }+constant_expression :+ conditional_expression { $1 }++{------------------------------------------------------------------------------+ -+ - Declarations+ -+ ------------------------------------------------------------------------------}++{-+-- XXX: This is an awful hack to get around problems with the interaction+-- between lexer feedback and the one-token lookahead that happy does. If we+-- encounter a typedef and the next token is the newly typedef'd type, we get an+-- error if we include the terminal semicolon directly in the productions for+-- declaration. By splitting the semicolon out, the lookahead token is+-- guaranteed not to be a typedef use :)+-}++declaration :: { InitGroup }+declaration :+ declaration_ ';' { $1 }++declaration_ :: { InitGroup }+declaration_ :+ declaration_specifiers+ {% do{ let (dspec, decl) = $1+ ; checkInitGroup dspec decl [] []+ }+ }+ | declaration_specifiers attributes+ {% do{ let (dspec, decl) = $1+ ; checkInitGroup dspec decl $2 []+ }+ }+ | declaration_specifiers init_declarator_list+ {% do{ let (dspec, decl) = $1+ ; let inits = rev $2+ ; checkInitGroup dspec decl [] (rev $2)+ }+ }+ | declaration_specifiers attributes init_declarator_list+ {% do{ let (dspec, decl) = $1+ ; checkInitGroup dspec decl $2 (rev $3)+ }+ }+ | declaration_specifiers error+ {% do{ let (_, decl) = $1+ ; expected (locOf decl) ["';'"]+ }+ }+ | ANTI_DECL+ { AntiDecl (getANTI_DECL $1) (locOf $1) }++declaration_specifiers :: { (DeclSpec, Decl) }+declaration_specifiers :+ ANTI_TYPE+ { let { v = getANTI_TYPE $1+ ; loc = locOf $1+ }+ in+ (AntiTypeDeclSpec [] [] v loc, AntiTypeDecl v loc)+ }+ | storage_qualifier_specifiers ANTI_TYPE+ { let { storage = mkStorage $1+ ; typeQuals = mkTypeQuals $1+ ; v = getANTI_TYPE $2+ ; loc = $1 <--> $2+ }+ in+ (AntiTypeDeclSpec storage typeQuals v loc, AntiTypeDecl v loc)+ }+ | nontypedef_declaration_specifiers+ { $1 }+ | typedef_declaration_specifiers+ { $1 }++nontypedef_declaration_specifiers :: { (DeclSpec, Decl) }+nontypedef_declaration_specifiers :+ ANTI_SPEC+ { let dspec = AntiDeclSpec (getANTI_SPEC $1) (locOf $1)+ in+ (dspec, DeclRoot (locOf $1))+ }+ | storage_qualifier_specifiers %prec NAMED+ {% do{ dspec <- mkDeclSpec $1+ ; return (dspec, DeclRoot (locOf $1))+ }+ }+ | type_specifier+ {% do{ dspec <- mkDeclSpec [$1]+ ; return (dspec, DeclRoot (locOf $1) )+ }+ }+ | type_specifier declaration_specifiers_+ {% do{ dspec <- mkDeclSpec ($1 : $2)+ ; return (dspec, DeclRoot ($1 <--> $2))+ }+ }+ | storage_qualifier_specifiers type_specifier+ {% do{ dspec <- mkDeclSpec ($1 ++ [$2])+ ; return $(dspec, DeclRoot ($1 <--> $2))+ }+ }+ | storage_qualifier_specifiers type_specifier declaration_specifiers_+ {% do{ dspec <- mkDeclSpec ($1 ++ $2 : $3)+ ; return (dspec, DeclRoot ($1 <--> $3))+ }+ }++typedef_declaration_specifiers :: { (DeclSpec, Decl) }+typedef_declaration_specifiers :+ typedef_name+ {% do{ dspec <- mkDeclSpec [$1]+ ; return (dspec, DeclRoot (locOf $1))+ }+ }+ | typedef_name storage_qualifier_specifiers+ {% do{ dspec <- mkDeclSpec ($1 : $2)+ ; return (dspec, DeclRoot ($1 <--> $2))+ }+ }+ | storage_qualifier_specifiers typedef_name+ {% do{ dspec <- mkDeclSpec ($1 ++ [$2])+ ; return (dspec, DeclRoot ($1 <--> $2))+ }+ }+ | storage_qualifier_specifiers typedef_name storage_qualifier_specifiers+ {% do{ dspec <- mkDeclSpec ($1 ++ $2 : $3)+ ; return (dspec, DeclRoot ($1 <--> $3))+ }+ }++declaration_specifiers_ :: { [TySpec] }+declaration_specifiers_ :+ storage_class_specifier %prec NAMED { [$1] }+ | storage_class_specifier declaration_specifiers_ { $1 : $2 }+ | type_specifier %prec NAMED { [$1] }+ | type_specifier declaration_specifiers_ { $1 : $2 }+ | type_qualifier %prec NAMED { [$1] }+ | type_qualifier declaration_specifiers_ { $1 : $2 }++-- | This production allows us to add storage class specifiers and type+-- qualifiers to an anti-quoted type.++storage_qualifier_specifiers :: { [TySpec] }+storage_qualifier_specifiers :+ storage_class_specifier %prec NAMED { [$1]}+ | storage_class_specifier storage_qualifier_specifiers { $1 : $2 }+ | type_qualifier %prec NAMED { [$1] }+ | type_qualifier storage_qualifier_specifiers { $1 : $2 }++init_declarator_list :: { RevList Init }+init_declarator_list :+ init_declarator { rsingleton $1 }+ | init_declarator_list ',' init_declarator { rcons $3 $1 }++maybe_asmlabel :: { Maybe AsmLabel }+maybe_asmlabel :+ {- empty -} { Nothing }+ | '__asm__' '(' STRING ')' { Just ((fst . getSTRING) $3) }++init_declarator :: { Init }+init_declarator :+ declarator maybe_asmlabel+ { let { (ident, declToDecl) = $1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Init ident decl $2 Nothing [] (ident <--> decl)+ }+ | declarator attributes maybe_asmlabel+ { let { (ident, declToDecl) = $1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Init ident decl $3 Nothing $2 (ident <--> decl)+ }+ | declarator maybe_asmlabel '=' initializer+ { let { (ident, declToDecl) = $1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Init ident decl $2 (Just $4) [] (ident <--> $4)+ }+ | declarator maybe_asmlabel '=' attributes initializer+ { let { (ident, declToDecl) = $1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Init ident decl $2 (Just $5) $4 (ident <--> $5)+ }+ | declarator error+ {% do{ let (ident, declToDecl) = $1+ ; let decl = declToDecl (declRoot ident)+ ; expected (locOf decl) ["'='"]+ }+ }++storage_class_specifier :: { TySpec }+storage_class_specifier :+ 'auto' { TSauto (locOf $1) }+ | 'register' { TSregister (locOf $1) }+ | 'static' { TSstatic (locOf $1) }+ | 'extern' { TSextern (locOf $1) }+ | 'extern' STRING { TSexternL ((snd . getSTRING) $2) (locOf $1) }+ | 'typedef' { TStypedef (locOf $1) }++type_specifier :: { TySpec }+type_specifier :+ 'void' { TSvoid (locOf $1) }+ | 'char' { TSchar (locOf $1) }+ | 'short' { TSshort (locOf $1) }+ | 'int' { TSint (locOf $1) }+ | 'long' { TSlong (locOf $1) }+ | 'float' { TSfloat (locOf $1) }+ | 'double' { TSdouble (locOf $1) }+ | 'signed' { TSsigned (locOf $1) }+ | 'unsigned' { TSunsigned (locOf $1) }+ | struct_or_union_specifier { $1 }+ | enum_specifier { $1 }++ {- Extension: GCC -}+ | '__builtin_va_list' { TSva_list (locOf $1) }++struct_or_union_specifier :: { TySpec }+struct_or_union_specifier :+ struct_or_union identifier_or_typedef+ { (unLoc $1) (Just $2) Nothing [] ($1 <--> $2) }+ | struct_or_union attributes identifier_or_typedef+ { (unLoc $1) (Just $3) Nothing $2 ($1 <--> $3) }+ | struct_or_union '{' struct_declaration_list '}'+ { (unLoc $1) Nothing (Just (rev $3)) [] ($1 <--> $4) }+ | struct_or_union '{' struct_declaration_list error+ {% unclosed ($1 <--> rev $3) "{" }+ | struct_or_union identifier_or_typedef '{' struct_declaration_list '}'+ { (unLoc $1) (Just $2) (Just (rev $4)) [] ($1 <--> $5) }+ | struct_or_union identifier_or_typedef '{' struct_declaration_list error+ {% unclosed ($1 <--> rev $4) "{" }+ | struct_or_union attributes identifier_or_typedef '{' struct_declaration_list '}'+ { (unLoc $1) (Just $3) (Just (rev $5)) $2 ($1 <--> $6) }+ | struct_or_union attributes identifier_or_typedef '{' struct_declaration_list error+ {% unclosed ($1 <--> rev $5) "{" }++struct_or_union :: { L (Maybe Id -> Maybe [FieldGroup] -> [Attr] -> SrcLoc -> TySpec) }+struct_or_union :+ 'struct' { L (getLoc $1) TSstruct }+ | 'union' { L (getLoc $1) TSunion }++struct_declaration_list :: { RevList FieldGroup }+struct_declaration_list :+ struct_declaration+ { rsingleton $1 }+ | ANTI_SDECLS+ { rsingleton (AntiSdecls (getANTI_SDECLS $1) (locOf $1)) }+ | struct_declaration_list struct_declaration+ { rcons $2 $1 }+ | struct_declaration_list ANTI_SDECLS+ { rcons (AntiSdecls (getANTI_SDECLS $2) (locOf $2)) $1 }++struct_declaration :: { FieldGroup }+struct_declaration :+ ANTI_SPEC struct_declarator_list ';'+ { let dspec = AntiDeclSpec (getANTI_SPEC $1) (locOf $1)+ in+ FieldGroup dspec (rev $2) ($1 <--> $3)+ }+ | specifier_qualifier_list struct_declarator_list ';'+ {% do{ dspec <- mkDeclSpec $1+ ; return $ FieldGroup dspec (rev $2) ($1 <--> $3)+ }+ }+ | ANTI_TYPE identifier_or_typedef ';'+ {% do{ let v = getANTI_TYPE $1+ ; let dspec = AntiTypeDeclSpec [] [] v (locOf $1)+ ; let decl = AntiTypeDecl v (locOf $1)+ ; let field = Field (Just $2) (Just decl) Nothing ($1 <--> $2)+ ; return $ FieldGroup dspec [field] ($1 <--> $3)+ }+ }+ | ANTI_SDECL+ { AntiSdecl (getANTI_SDECL $1) (locOf $1) }++specifier_qualifier_list :: { [TySpec] }+specifier_qualifier_list :+ type_specifier specifier_qualifier_list_+ { $1 : $2 }+ | type_qualifier_list type_specifier specifier_qualifier_list_+ { rev $1 ++ [$2] ++ $3 }+ | typedef_name+ { [$1] }+ | typedef_name type_qualifier_list+ { $1 : rev $2 }+ | type_qualifier_list typedef_name+ { rev $1 ++ [$2] }+ | type_qualifier_list typedef_name type_qualifier_list+ { rev $1 ++ [$2] ++ rev $3 }++specifier_qualifier_list_ :: { [TySpec] }+specifier_qualifier_list_ :+ {- empty -} %prec NAMED { [] }+ | type_specifier %prec NAMED { [$1] }+ | type_specifier specifier_qualifier_list { $1 : $2 }+ | type_qualifier %prec NAMED { [$1] }+ | type_qualifier specifier_qualifier_list { $1 : $2 }++struct_declarator_list :: { RevList Field }+struct_declarator_list :+ struct_declarator { rsingleton $1 }+ | struct_declarator_list ',' struct_declarator { rcons $3 $1 }++struct_declarator :: { Field }+struct_declarator :+ declarator+ { let { (ident, declToDecl) = $1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Field (Just ident) (Just decl) Nothing (locOf decl)+ }+ | declarator attributes+ { let { (ident, declToDecl) = $1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Field (Just ident) (Just decl) Nothing (locOf decl)+ }+ | ':' constant_expression+ { Field Nothing Nothing (Just $2) ($1 <--> $2) }+ | declarator ':' constant_expression+ { let { (ident, declToDecl) = $1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Field (Just ident) (Just decl) (Just $3) (locOf decl)+ }++enum_specifier :: { TySpec }+enum_specifier :+ 'enum' identifier_or_typedef+ { TSenum (Just $2) [] [] ($1 <--> $2) }+ | 'enum' attributes identifier_or_typedef+ { TSenum (Just $3) [] $2 ($1 <--> $3) }+ | 'enum' '{' enumerator_list '}'+ { TSenum Nothing (rev $3) [] ($1 <--> $4) }+ | 'enum' identifier_or_typedef '{' enumerator_list '}'+ { TSenum (Just $2) (rev $4) [] ($1 <--> $5)}++enumerator_list :: { RevList CEnum }+enumerator_list :+ enumerator+ { rsingleton $1 }+ | ANTI_ENUMS+ { rsingleton (AntiEnums (getANTI_ENUMS $1) (locOf $1)) }+ | enumerator_list ','+ { $1 }+ | enumerator_list ',' enumerator+ { rcons $3 $1 }+ | enumerator_list ',' ANTI_ENUMS+ { rcons (AntiEnums (getANTI_ENUMS $3) (locOf $3)) $1 }++enumerator :: { CEnum }+enumerator:+ identifier+ { CEnum $1 Nothing (locOf $1)}+ | identifier '=' constant_expression+ { CEnum $1 (Just $3) ($1 <--> $3) }+ | ANTI_ENUM+ { AntiEnum (getANTI_ENUM $1) (locOf $1) }++type_qualifier :: { TySpec }+type_qualifier :+ 'const' { TSconst (locOf $1) }+ | 'inline' { TSinline (locOf $1) }+ | 'restrict' { TSrestrict (locOf $1) }+ | 'volatile' { TSvolatile (locOf $1) }++ {- Extension: CUDA -}+ | '__device__' { TSdevice (locOf $1) }+ | '__global__' { TSglobal (locOf $1) }+ | '__host__' { TShost (locOf $1) }+ | '__constant__' { TSconstant (locOf $1) }+ | '__shared__' { TSshared (locOf $1) }+ | '__noinline__' { TSnoinline (locOf $1) }++-- Consider the following C program:+--+-- typedef struct foo {+-- int a;+-- } foo;+--+-- void f(foo* (foo));+--+-- In the grammar in the C99 standard, a parameter declaration can result from+-- either a declarator or an abstract declarator. This produces an ambiguity+-- when a typedef name appears after '(' because we can't tell whether or not it+-- is an item in a parmeter list for a function that is part of an abstract+-- declarator, or if is just a parenthesized (standard) declarator. This+-- ambiguity exists in the definition of f in the above program.+--+-- To solve this ambiguity, we split the the declarator rule to handle the+-- identifier and typedef name cases separately, and, furthermore, copy the+-- typedef name declarator rule and remove the cases that leads to ambiguity+-- when a declarator is used in a parameter list declaration.++identifier_declarator :: { (Id, Decl -> Decl) }+identifier_declarator :+ identifier_direct_declarator+ { $1 }+ | pointer identifier_direct_declarator+ { let (ident, dirDecl) = $2+ in+ (ident, dirDecl . $1)+ }++identifier_direct_declarator :: { (Id, Decl -> Decl) }+identifier_direct_declarator :+ identifier+ { ($1, id) }+ | '(' identifier_declarator ')'+ { $2 }+ | '(' identifier_declarator error+ {%do { let (ident, declToDecl) = $2+ ; let decl = declToDecl (declRoot ident)+ ; unclosed ($1 <--> decl) "("+ }+ }+ | identifier_direct_declarator array_declarator+ { let (ident, declToDecl) = $1+ in+ (ident, declToDecl . $2)+ }+ | identifier_direct_declarator '(' ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkOldProto []+ }+ in+ (ident, declToDecl . proto)+ }+ | identifier_direct_declarator '(' parameter_type_list ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkProto $3+ }+ in+ (ident, declToDecl . proto)+ }+ | identifier_direct_declarator '(' identifier_list ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkOldProto (rev $3)+ }+ in+ (ident, declToDecl . proto)+ }++typedef_declarator :: { (Id, Decl -> Decl) }+typedef_declarator :+ typedef_direct_declarator+ { $1 }+ | pointer typedef_direct_declarator+ { let (ident, dirDecl) = $2+ in+ (ident, dirDecl . $1)+ }++typedef_direct_declarator :: { (Id, Decl -> Decl) }+typedef_direct_declarator :+ NAMED+ { (Id (getNAMED $1) (locOf $1), id) }+ | '(' typedef_declarator ')'+ { $2 }+ | '(' typedef_declarator error+ {%do { let (ident, declToDecl) = $2+ ; let decl = declToDecl (declRoot ident)+ ; unclosed ($1 <--> decl) "("+ }+ }+ | typedef_direct_declarator array_declarator+ { let (ident, declToDecl) = $1+ in+ (ident, declToDecl . $2)+ }+ | typedef_direct_declarator '(' ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkOldProto []+ }+ in+ (ident, declToDecl . proto)+ }+ | typedef_direct_declarator '(' parameter_type_list ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkProto $3+ }+ in+ (ident, declToDecl . proto)+ }+ | typedef_direct_declarator '(' identifier_list ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkOldProto (rev $3)+ }+ in+ (ident, declToDecl . proto)+ }++declarator :: { (Id, Decl -> Decl) }+declarator :+ identifier_declarator+ { $1 }+ | typedef_declarator+ { $1 }++parameter_typedef_declarator :: { (Id, Decl -> Decl) }+parameter_typedef_declarator :+ parameter_typedef_direct_declarator+ { $1 }+ | pointer parameter_typedef_direct_declarator+ { let (ident, dirDecl) = $2+ in+ (ident, dirDecl . $1)+ }++parameter_typedef_direct_declarator :: { (Id, Decl -> Decl) }+parameter_typedef_direct_declarator :+ NAMED+ { (Id (getNAMED $1) (locOf $1), id) }+ | '(' pointer parameter_typedef_direct_declarator ')'+ { let (ident, dirDecl) = $3+ in+ (ident, dirDecl . $2)+ }+ | parameter_typedef_direct_declarator array_declarator+ { let (ident, declToDecl) = $1+ in+ (ident, declToDecl . $2)+ }+ | parameter_typedef_direct_declarator '(' ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkOldProto []+ }+ in+ (ident, declToDecl . proto)+ }+ | parameter_typedef_direct_declarator '(' parameter_type_list ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkProto $3+ }+ in+ (ident, declToDecl . proto)+ }+ | parameter_typedef_direct_declarator '(' identifier_list ')'+ { let { (ident, declToDecl) = $1+ ; proto = mkOldProto (rev $3)+ }+ in+ (ident, declToDecl . proto)+ }++parameter_declarator :: { (Id, Decl -> Decl) }+parameter_declarator :+ identifier_declarator+ { $1 }+ | parameter_typedef_declarator+ { $1 }++array_declarator :: { Decl -> Decl }+array_declarator :+ '[' ']'+ { mkArray [] (NoArraySize ($1 <--> $2)) }+ | '[' error+ {% unclosed (getLoc $1) "[" }+ | '[' type_qualifier_list ']'+ { mkArray (rev $2) (NoArraySize ($1 <--> $3)) }+ | '[' assignment_expression ']'+ { mkArray [] (ArraySize False $2 (locOf $2)) }+ | '[' type_qualifier_list assignment_expression ']'+ { mkArray (rev $2) (ArraySize False $3 (locOf $3)) }+ | '[' 'static' assignment_expression ']'+ { mkArray [] (ArraySize True $3 (locOf $3)) }+ | '[' 'static' type_qualifier_list assignment_expression ']'+ { mkArray (rev $3) (ArraySize True $4 (locOf $4)) }+ | '[' type_qualifier_list 'static' assignment_expression ']'+ { mkArray (rev $2) (ArraySize True $4 (locOf $4)) }+ | '[' '*' ']'+ { mkArray [] (VariableArraySize ($1 <--> $3)) }+ | '[' type_qualifier_list '*' ']'+ { mkArray (rev $2) (VariableArraySize ($1 <--> $4)) }++pointer :: { Decl -> Decl }+pointer :+ '*' { mkPtr [] }+ | '*' type_qualifier_list { mkPtr (rev $2) }+ | '*' pointer { $2 . mkPtr [] }+ | '*' type_qualifier_list pointer { $3 . mkPtr (rev $2) }++type_qualifier_list :: { RevList TySpec }+type_qualifier_list :+ type_qualifier { rsingleton $1 }+ | type_qualifier_list type_qualifier { rcons $2 $1 }++parameter_type_list :: { Params }+parameter_type_list :+ parameter_list+ { let params = rev $1+ in+ Params params False (locOf params)+ }+ | parameter_list ',' '...'+ { let params = rev $1+ in+ Params params True (params <--> $3)+ }++parameter_list :: { RevList Param }+parameter_list:+ parameter_declaration+ { rsingleton $1 }+ | ANTI_PARAMS+ { rsingleton (AntiParams (getANTI_PARAMS $1) (locOf $1)) }+ | parameter_list ',' parameter_declaration+ { rcons $3 $1 }+ | parameter_list ',' ANTI_PARAMS+ { rcons (AntiParams (getANTI_PARAMS $3) (locOf $3)) $1 }++parameter_declaration :: { Param }+parameter_declaration:+ declaration_specifiers+ { let (dspec, decl) = $1+ in+ Param Nothing dspec decl (dspec <--> decl)+ }+ | declaration_specifiers parameter_declarator+ { let { (dspec, declRoot) = $1+ ; (ident, declToDecl) = $2+ ; decl = declToDecl declRoot+ }+ in+ Param (Just ident) dspec decl (ident <--> decl)+ }+ | declaration_specifiers abstract_declarator+ { let { (dspec, declRoot) = $1+ ; decl = $2 declRoot+ }+ in+ Param Nothing dspec decl (dspec <--> decl)+ }+ | ANTI_PARAM+ { AntiParam (getANTI_PARAM $1) (locOf $1) }++-- The type_declaration rule is the parameter_declaration rule without the+-- ANTI_PARAM option. This allows us to parse type declarations easily for later+-- antiquoting.++type_declaration :: { Type }+type_declaration:+ declaration_specifiers+ { let (dspec, decl) = $1+ in+ Type dspec decl (dspec <--> decl)+ }+ | declaration_specifiers parameter_declarator+ { let { (dspec, declRoot) = $1+ ; (ident, declToDecl) = $2+ ; decl = declToDecl declRoot+ }+ in+ Type dspec decl (dspec <--> decl)+ }+ | declaration_specifiers abstract_declarator+ { let { (dspec, declRoot) = $1+ ; decl = $2 declRoot+ }+ in+ Type dspec decl (dspec <--> decl)+ }++identifier_list :: { RevList Id }+identifier_list :+ identifier { rsingleton $1 }+ | identifier_list ',' identifier { rcons $3 $1 }++type_name :: { Type }+type_name :+ ANTI_SPEC+ { let dspec = AntiDeclSpec (getANTI_SPEC $1) (locOf $1)+ in+ Type dspec (declRoot $1) (locOf $1)+ }+ | specifier_qualifier_list+ {% do{ dspec <- mkDeclSpec $1+ ; return $ Type dspec (declRoot $1) (locOf $1)+ }+ }+ | ANTI_SPEC abstract_declarator+ { let { dspec = AntiDeclSpec (getANTI_SPEC $1) (locOf $1)+ ; decl = $2 (declRoot $1)+ }+ in+ Type dspec decl (dspec <--> decl)+ }+ | specifier_qualifier_list abstract_declarator+ {% do{ let decl = $2 (declRoot $1)+ ; dspec <- mkDeclSpec $1+ ; return $ Type dspec decl (dspec <--> decl)+ }+ }+ | ANTI_TYPE+ { AntiType (getANTI_TYPE $1) (locOf $1) }+ | ANTI_TYPE abstract_declarator+ { let { v = getANTI_TYPE $1+ ; decl = $2 (AntiTypeDecl v (locOf $1))+ }+ in+ Type (AntiTypeDeclSpec [] [] v (locOf $1)) decl ($1 <--> decl)+ }++abstract_declarator :: { Decl -> Decl }+abstract_declarator :+ pointer { $1 }+ | direct_abstract_declarator { $1 }+ | pointer direct_abstract_declarator { $2 . $1 }++direct_abstract_declarator :: { Decl -> Decl }+direct_abstract_declarator :+ '(' abstract_declarator ')'+ { $2 }+ | '(' abstract_declarator error+ {% do{ let decl = $2 (declRoot $1)+ ; unclosed ($1 <--> decl) "("+ }+ }+ | array_declarator+ { $1 }+ | direct_abstract_declarator array_declarator+ { $1 . $2 }+ | '(' ')'+ { mkOldProto [] }+ | '(' parameter_type_list ')'+ { mkProto $2 }+ | direct_abstract_declarator '(' ')'+ { $1 . mkOldProto [] }+ | direct_abstract_declarator '(' parameter_type_list ')'+ { $1 . mkProto $3 }++typedef_name :: { TySpec }+typedef_name :+ NAMED+ { TSnamed (Id (getNAMED $1) (locOf $1)) (locOf $1) }+ | 'typename' identifier+ { TSnamed $2 ($1 <--> $2) }+ | 'typename' error+ {% expected (locOf $1) ["identifier"] }+ | '__typeof__' '(' unary_expression ')'+ { TStypeofExp $3 ($1 <--> $4) }+ | '__typeof__' '(' type_name ')'+ { TStypeofType $3 ($1 <--> $4) }+ | '__typeof__' '(' type_name error+ {% unclosed ($2 <--> $3) "(" }++initializer :: { Initializer }+initializer :+ assignment_expression+ { ExpInitializer $1 (locOf $1) }+ | '{' initializer_list '}'+ { CompoundInitializer (rev $2) ($1 <--> $3) }+ | '{' initializer_list error+ {% do{ let (_, inits) = unzip (rev $2)+ ; unclosed ($1 <--> inits) "{"+ }+ }+ | '{' initializer_list ',' '}'+ { CompoundInitializer (rev $2) ($1 <--> $4) }+ | '{' initializer_list ',' error+ {% unclosed ($1 <--> $3) "{" }++initializer_list :: { RevList (Maybe Designation, Initializer) }+initializer_list :+ initializer+ { rsingleton (Nothing, $1) }+ | designation initializer+ { rsingleton (Just $1, $2) }+ | initializer_list ',' initializer+ { rcons (Nothing, $3) $1 }+ | initializer_list ',' designation initializer+ { rcons (Just $3, $4) $1 }++designation :: { Designation }+designation :+ designator_list '='+ { let designators = rev $1+ in+ Designation designators (designators <--> $2)+ }++designator_list :: { RevList Designator }+designator_list :+ designator { rsingleton $1 }+ | designator_list designator { rcons $2 $1 }++designator :: { Designator }+designator :+ '[' constant_expression ']'+ { IndexDesignator $2 ($1 <--> $3) }+ | '.' identifier+ { MemberDesignator $2 ($1 <--> $2) }++{------------------------------------------------------------------------------+ -+ - Statements+ -+ ------------------------------------------------------------------------------}++statement :: { Stm }+statement :+ labeled_statement { $1 }+ | compound_statement { $1 }+ | expression_statement { $1 }+ | selection_statement { $1 }+ | iteration_statement { $1 }+ | jump_statement { $1 }+ | asm_statement { $1 }+ | ANTI_STM { AntiStm (getANTI_STM $1) (locOf $1) }++labeled_statement :: { Stm }+labeled_statement :+ identifier ':' statement { Label $1 $3 ($1 <--> $3) }+ | 'case' constant_expression ':' statement { Case $2 $4 ($1 <--> $4) }+ | 'default' ':' statement { Default $3 ($1 <--> $3) }++compound_statement :: { Stm }+compound_statement:+ '{' begin_scope end_scope '}'+ { Block [] ($1 <--> $4) }+ | '{' begin_scope error+ {% unclosed (locOf $3) "{" }+ | '{' begin_scope block_item_list end_scope '}'+ { Block (rev $3) ($1 <--> $5) }++block_item_list :: { RevList BlockItem }+block_item_list :+ block_item { rsingleton $1 }+ | block_item_list block_item { rcons $2 $1 }++block_item :: { BlockItem }+block_item :+ declaration { BlockDecl $1 }+ | statement { BlockStm $1 }+ | ANTI_DECLS { BlockDecl (AntiDecls (getANTI_DECLS $1) (locOf $1)) }+ | ANTI_STMS { BlockStm (AntiStms (getANTI_STMS $1) (locOf $1)) }+ | ANTI_ITEM { AntiBlockItem (getANTI_ITEM $1) (locOf $1) }+ | ANTI_ITEMS { AntiBlockItems (getANTI_ITEMS $1) (locOf $1) }++begin_scope :: { () }+begin_scope : {% pushScope }++end_scope :: { () }+end_scope : {% popScope }++declaration_list :: { RevList InitGroup }+declaration_list :+ declaration+ { rsingleton $1 }+ | ANTI_DECLS+ { rsingleton (AntiDecls (getANTI_DECLS $1) (locOf $1)) }+ | declaration_list declaration+ { rcons $2 $1 }+ | declaration_list ANTI_DECLS+ { rcons (AntiDecls (getANTI_DECLS $2) (locOf $2)) $1 }++expression_statement :: { Stm }+expression_statement:+ ';' { Exp Nothing (locOf $1) }+ | expression ';' { Exp (Just $1) ($1 <--> $2) }+ | expression error {% expected (locOf $1) ["';'"] }++selection_statement :: { Stm }+selection_statement :+ 'if' '(' expression ')' statement+ { If $3 $5 Nothing ($1 <--> $5) }+ | 'if' '(' expression ')' statement 'else' statement+ { If $3 $5 (Just $7) ($1 <--> $7) }+ | 'if' '(' expression error+ {% unclosed ($2 <--> $3) "(" }+ | 'switch' '(' expression ')' statement+ { Switch $3 $5 ($1 <--> $5) }+ | 'switch' '(' expression error+ {% unclosed ($2 <--> $3) "(" }++iteration_statement :: { Stm }+iteration_statement :+ 'while' '(' expression ')' statement+ { While $3 $5 ($1 <--> $5) }+ | 'while' '(' expression error+ {% unclosed ($2 <--> $3) "(" }+ | 'do' statement 'while' '(' expression ')' ';'+ { DoWhile $2 $5 ($1 <--> $7) }+ | 'do' statement 'while' '(' expression error+ {% unclosed ($4 <--> $5) "(" }+ | 'for' '(' error+ {% expected (locOf $2) ["expression", "declaration"] }+ | 'for' '(' declaration maybe_expression ';' ')' statement+ { For (Left $3) $4 Nothing $7 ($1 <--> $7) }+ | 'for' '(' maybe_expression ';' maybe_expression ';' ')' statement+ { For (Right $3) $5 Nothing $8 ($1 <--> $8) }+ | 'for' '(' maybe_expression ';' maybe_expression ';' error+ {% unclosed ($2 <--> $6) "(" }+ | 'for' '(' declaration maybe_expression ';' expression ')' statement+ { For (Left $3) $4 (Just $6) $8 ($1 <--> $8) }+ | 'for' '(' maybe_expression ';' maybe_expression ';' expression ')' statement+ { For (Right $3) $5 (Just $7) $9 ($1 <--> $9) }+ | 'for' '(' maybe_expression ';' maybe_expression ';' expression error+ {% unclosed ($2 <--> $7) "(" }++jump_statement :: { Stm }+jump_statement :+ 'goto' identifier ';' { Goto $2 ($1 <--> $3) }+ | 'goto' error {% expected (locOf $1) ["identifier"] }+ | 'goto' identifier error {% expected (locOf $2) ["';'"] }+ | 'continue' ';' { Continue ($1 <--> $2) }+ | 'continue' error {% expected (locOf $1) ["';'"] }+ | 'break' ';' { Break ($1 <--> $2) }+ | 'break' error {% expected (locOf $1) ["';'"] }+ | 'return' ';' { Return Nothing ($1 <--> $2) }+ | 'return' error {% expected (locOf $1) ["';'"] }+ | 'return' expression ';' { Return (Just $2) ($1 <--> $3) }+ | 'return' expression error {% expected (locOf $2) ["';'"] }++{------------------------------------------------------------------------------+ -+ - External definitions+ -+ ------------------------------------------------------------------------------}++translation_unit :: { [Definition] }+translation_unit :+ {- empty -}+ { [] }+ | translation_unit_ { rev $1 }++translation_unit_ :: { RevList Definition }+translation_unit_ :+ external_declaration+ { rsingleton $1 }+ | ANTI_EDECLS+ { rsingleton (AntiEdecls (getANTI_EDECLS $1) (locOf $1)) }+ | translation_unit_ external_declaration+ { rcons $2 $1 }+ | translation_unit_ ANTI_EDECLS+ { rcons (AntiEdecls (getANTI_EDECLS $2) (locOf $2)) $1 }++external_declaration :: { Definition }+external_declaration :+ function_definition+ { FuncDef $1 (locOf $1) }+ | declaration+ { DecDef $1 (locOf $1) }+ | ANTI_FUNC+ { AntiFunc (getANTI_FUNC $1) (locOf $1) }+ | ANTI_ESC+ { AntiEsc (getANTI_ESC $1) (locOf $1) }+ | ANTI_EDECL+ { AntiEdecl (getANTI_EDECL $1) (locOf $1) }++function_definition :: { Func }+function_definition :+ declaration_specifiers declarator compound_statement+ {% do{ let (dspec, declRoot) = $1+ ; let (ident, declToDecl) = $2+ ; let Block blockItems _ = $3+ ; let decl = declToDecl declRoot+ ; case decl of+ { Proto protoDecl args _ -> return $+ Func dspec ident protoDecl args+ blockItems+ (decl <--> blockItems)+ ; OldProto protoDecl args _ -> return $+ OldFunc dspec ident protoDecl args Nothing+ blockItems+ (decl <--> blockItems)+ ; _ -> failAt (decl <--> blockItems :: Loc)+ "bad function declaration"+ }+ }+ }+ | declaration_specifiers declarator declaration_list compound_statement+ {% do{ let (dspec, declRoot) = $1+ ; let (ident, declToDecl) = $2+ ; let argDecls = $3+ ; let Block blockItems _ = $4+ ; let decl = declToDecl declRoot+ ; case decl of+ { OldProto protoDecl args _ -> return $+ OldFunc dspec ident protoDecl args (Just (rev argDecls))+ blockItems+ (decl <--> blockItems)+ ; _ -> failAt (decl <--> blockItems :: Loc)+ "bad function declaration"+ }+ }+ }++{------------------------------------------------------------------------------+ -+ - GCC extensions+ -+ ------------------------------------------------------------------------------}++attributes :: { [Attr] }+attributes :+ attribute { $1 }+ | attributes attribute { $1 ++ $2 }++attribute :: { [Attr] }+attribute :+ '__attribute__' '(' '(' attribute_list ')' ')' { rev $4 }++attribute_list :: { RevList Attr }+attribute_list :+ attrib { rsingleton $1 }+ | attribute_list ',' attrib { rcons $3 $1 }++attrib :: { Attr }+attrib :+ attrib_name+ { Attr $1 [] (locOf $1)}+ | attrib_name '(' argument_expression_list ')'+ { Attr $1 (rev $3) ($1 <--> $4) }++attrib_name :: { Id }+attrib_name :+ identifier_or_typedef { $1 }+ | 'static' { Id "static" (locOf $1) }+ | 'extern' { Id "extern" (locOf $1) }+ | 'register' { Id "register" (locOf $1) }+ | 'typedef' { Id "typedef" (locOf $1) }+ | 'inline' { Id "inline" (locOf $1) }+ | 'auto' { Id "auto" (locOf $1) }+ | 'const' { Id "const" (locOf $1) }+ | 'volatile' { Id "volatile" (locOf $1) }+ | 'unsigned' { Id "unsigned" (locOf $1) }+ | 'long' { Id "long" (locOf $1) }+ | 'short' { Id "short" (locOf $1) }+ | 'signed' { Id "signed" (locOf $1) }+ | 'int' { Id "int" (locOf $1) }+ | 'char' { Id "char" (locOf $1) }+ | 'float' { Id "float" (locOf $1) }+ | 'double' { Id "double" (locOf $1) }+ | 'void' { Id "void" (locOf $1) }++maybe_volatile :: { Bool }+maybe_volatile :+ {- empty -} { False}+ | 'volatile' { True}++asm_statement :: { Stm }+asm_statement :+ '__asm__' maybe_volatile '(' asm_template ')' ';'+ { Asm $2 [] (rev $4) [] [] [] ($1 <--> $5) }+ | '__asm__' maybe_volatile '(' asm_template ':' asm_inouts ')' ';'+ { Asm $2 [] (rev $4) $6 [] [] ($1 <--> $7) }+ | '__asm__' maybe_volatile '(' asm_template ':' asm_inouts+ ':' asm_inouts ')' ';'+ { Asm $2 [] (rev $4) $6 $8 [] ($1 <--> $9) }+ | '__asm__' maybe_volatile '(' asm_template ':' asm_inouts+ ':' asm_inouts+ ':' asm_clobbers ')' ';'+ { Asm $2 [] (rev $4) $6 $8 $10 ($1 <--> $11) }++asm_template :: { RevList String }+asm_template :+ STRING { rsingleton ((fst . getSTRING) $1) }+ | asm_template STRING { rcons ((fst . getSTRING) $2) $1 }++asm_inouts :: { [(String, Exp)] }+asm_inouts :+ {- empty -} { [] }+ | asm_inouts_ne { rev $1 }++asm_inouts_ne :: { RevList (String, Exp) }+asm_inouts_ne:+ asm_inout { rsingleton $1 }+ | asm_inouts_ne ',' asm_inout { rcons $3 $1 }++asm_inout :: { (String, Exp) }+asm_inout :+ STRING '(' expression ')' { ((fst . getSTRING) $1, $3) }++asm_clobbers :: { [String] }+asm_clobbers :+ {- empty -} { [] }+ | asm_clobbers_ne { rev $1 }++asm_clobbers_ne :: { RevList String }+asm_clobbers_ne :+ asm_clobber { rsingleton $1 }+ | asm_clobbers_ne ',' asm_clobber { rcons $3 $1 }++asm_clobber :: { String }+asm_clobber :+ STRING { (fst . getSTRING) $1 }++{+happyError :: L T.Token -> P a+happyError (L (Loc start _) _) =+ throw $ ParserException (Loc start start) (text "parse error")++getCHAR (L _ (T.TcharConst x)) = x+getSTRING (L _ (T.TstringConst x)) = x+getINT (L _ (T.TintConst x)) = x+getLONG (L _ (T.TlongIntConst x)) = x+getLONG_LONG (L _ (T.TlongLongIntConst x)) = x+getFLOAT (L _ (T.TfloatConst x)) = x+getDOUBLE (L _ (T.TdoubleConst x)) = x+getLONG_DOUBLE (L _ (T.TlongDoubleConst x)) = x+getID (L _ (T.Tidentifier id)) = id+getNAMED (L _ (T.Tnamed id)) = id++getANTI_ID (L _ (T.Tanti_id v)) = v+getANTI_INT (L _ (T.Tanti_int v)) = v+getANTI_UINT (L _ (T.Tanti_uint v)) = v+getANTI_LINT (L _ (T.Tanti_lint v)) = v+getANTI_ULINT (L _ (T.Tanti_ulint v)) = v+getANTI_FLOAT (L _ (T.Tanti_float v)) = v+getANTI_DOUBLE (L _ (T.Tanti_double v)) = v+getANTI_LONG_DOUBLE (L _ (T.Tanti_long_double v)) = v+getANTI_CHAR (L _ (T.Tanti_char v)) = v+getANTI_STRING (L _ (T.Tanti_string v)) = v+getANTI_EXP (L _ (T.Tanti_exp v)) = v+getANTI_FUNC (L _ (T.Tanti_func v)) = v+getANTI_ARGS (L _ (T.Tanti_args v)) = v+getANTI_DECL (L _ (T.Tanti_decl v)) = v+getANTI_DECLS (L _ (T.Tanti_decls v)) = v+getANTI_SDECL (L _ (T.Tanti_sdecl v)) = v+getANTI_SDECLS (L _ (T.Tanti_sdecls v)) = v+getANTI_ENUM (L _ (T.Tanti_enum v)) = v+getANTI_ENUMS (L _ (T.Tanti_enums v)) = v+getANTI_ESC (L _ (T.Tanti_esc v)) = v+getANTI_EDECL (L _ (T.Tanti_edecl v)) = v+getANTI_EDECLS (L _ (T.Tanti_edecls v)) = v+getANTI_ITEM (L _ (T.Tanti_item v)) = v+getANTI_ITEMS (L _ (T.Tanti_items v)) = v+getANTI_STM (L _ (T.Tanti_stm v)) = v+getANTI_STMS (L _ (T.Tanti_stms v)) = v+getANTI_TYPE (L _ (T.Tanti_type v)) = v+getANTI_SPEC (L _ (T.Tanti_spec v)) = v+getANTI_PARAM (L _ (T.Tanti_param v)) = v+getANTI_PARAMS (L _ (T.Tanti_params v)) = v++lexer :: (L T.Token -> P a) -> P a+lexer cont = do+ tok <- lexToken+ cont tok++locate :: Loc -> (SrcLoc -> a) -> L a+locate loc f = L loc (f (SrcLoc loc))++data DeclTySpec = DeclTySpec DeclSpec !SrcLoc+ | AntiDeclTySpec String !SrcLoc++data TySpec = TSauto !SrcLoc+ | TSregister !SrcLoc+ | TSstatic !SrcLoc+ | TSextern !SrcLoc+ | TSexternL String !SrcLoc+ | TStypedef !SrcLoc++ | TSconst !SrcLoc+ | TSvolatile !SrcLoc+ | TSinline !SrcLoc++ | TSsigned !SrcLoc+ | TSunsigned !SrcLoc++ | TSvoid !SrcLoc+ | TSchar !SrcLoc+ | TSshort !SrcLoc+ | TSint !SrcLoc+ | TSlong !SrcLoc+ | TSfloat !SrcLoc+ | TSdouble !SrcLoc++ | TSstruct (Maybe Id) (Maybe [FieldGroup]) [Attr] !SrcLoc+ | TSunion (Maybe Id) (Maybe [FieldGroup]) [Attr] !SrcLoc+ | TSenum (Maybe Id) [CEnum] [Attr] !SrcLoc+ | TSnamed Id !SrcLoc++ | TStypeofExp Exp !SrcLoc+ | TStypeofType Type !SrcLoc+ | TSva_list !SrcLoc++ -- C99+ | TSrestrict !SrcLoc++ -- CUDA+ | TSdevice !SrcLoc+ | TSglobal !SrcLoc+ | TShost !SrcLoc+ | TSconstant !SrcLoc+ | TSshared !SrcLoc+ | TSnoinline !SrcLoc++instance Located DeclTySpec where+ getLoc (DeclTySpec _ loc) = getLoc loc+ getLoc (AntiDeclTySpec _ loc) = getLoc loc++instance Located TySpec where+ getLoc (TSauto loc) = getLoc loc+ getLoc (TSregister loc) = getLoc loc+ getLoc (TSstatic loc) = getLoc loc+ getLoc (TSextern loc) = getLoc loc+ getLoc (TSexternL _ loc) = getLoc loc+ getLoc (TStypedef loc) = getLoc loc++ getLoc (TSconst loc) = getLoc loc+ getLoc (TSvolatile loc) = getLoc loc+ getLoc (TSinline loc) = getLoc loc++ getLoc (TSsigned loc) = getLoc loc+ getLoc (TSunsigned loc) = getLoc loc++ getLoc (TSvoid loc) = getLoc loc+ getLoc (TSchar loc) = getLoc loc+ getLoc (TSshort loc) = getLoc loc+ getLoc (TSint loc) = getLoc loc+ getLoc (TSlong loc) = getLoc loc+ getLoc (TSfloat loc) = getLoc loc+ getLoc (TSdouble loc) = getLoc loc++ getLoc (TSstruct _ _ _ loc) = getLoc loc+ getLoc (TSunion _ _ _ loc) = getLoc loc+ getLoc (TSenum _ _ _ loc) = getLoc loc+ getLoc (TSnamed _ loc) = getLoc loc++ getLoc (TStypeofExp _ loc) = getLoc loc+ getLoc (TStypeofType _ loc) = getLoc loc+ getLoc (TSva_list loc) = getLoc loc++ getLoc (TSrestrict loc) = getLoc loc++ getLoc (TSdevice loc) = getLoc loc+ getLoc (TSglobal loc) = getLoc loc+ getLoc (TShost loc) = getLoc loc+ getLoc (TSconstant loc) = getLoc loc+ getLoc (TSshared loc) = getLoc loc+ getLoc (TSnoinline loc) = getLoc loc++instance Pretty TySpec where+ ppr (TSauto _) = text "auto"+ ppr (TSregister _) = text "register"+ ppr (TSstatic _) = text "static"+ ppr (TSextern _) = text "extern"+ ppr (TSexternL l _) = text "extern" <+> ppr l+ ppr (TStypedef _) = text "typedef"++ ppr (TSconst _) = text "const"+ ppr (TSinline _) = text "inline"+ ppr (TSrestrict _) = text "restrict"+ ppr (TSvolatile _) = text "volatile"++ ppr (TSsigned _) = text "signed"+ ppr (TSunsigned _) = text "unsigned"++ ppr (TSvoid _) = text "void"+ ppr (TSchar _) = text "char"+ ppr (TSshort _) = text "short"+ ppr (TSint _) = text "int"+ ppr (TSlong _) = text "long"+ ppr (TSfloat _) = text "float"+ ppr (TSdouble _) = text "double"++ ppr (TSstruct maybe_id maybe_fields attrs _) =+ pprStructOrUnion "struct" maybe_id maybe_fields attrs++ ppr (TSunion maybe_id maybe_fields attrs _) =+ pprStructOrUnion "union" maybe_id maybe_fields attrs++ ppr (TSenum maybe_id cenums attrs _) =+ pprEnum maybe_id cenums attrs++ ppr (TStypeofExp e _) = text "__typeof__" <> parens (ppr e)+ ppr (TStypeofType ty _) = text "__typeof__" <> parens (ppr ty)+ ppr (TSnamed ident _) = ppr ident++ ppr (TSva_list _) = text "__builtin_va_list"++ ppr (TSdevice _) = text "__device__"+ ppr (TSglobal _) = text "__global__"+ ppr (TShost _) = text "__host__"+ ppr (TSconstant _) = text "__constant__"+ ppr (TSshared _) = text "__shared__"+ ppr (TSnoinline _) = text "__noinline__"++isStorage :: TySpec -> Bool+isStorage (TSauto _) = True+isStorage (TSregister _) = True+isStorage (TSstatic _) = True+isStorage (TSextern _) = True+isStorage (TSexternL _ _) = True+isStorage (TStypedef _) = True+isStorage _ = False++mkStorage :: [TySpec] -> [Storage]+mkStorage specs = map mk (filter isStorage specs)+ where+ mk :: TySpec -> Storage+ mk (TSauto loc) = Tauto loc+ mk (TSregister loc) = Tregister loc+ mk (TSstatic loc) = Tstatic loc+ mk (TSextern loc) = Textern loc+ mk (TSexternL l loc) = TexternL l loc+ mk (TStypedef loc) = Ttypedef loc+ mk _ = error "internal error in mkStorage"++isTypeQual :: TySpec -> Bool+isTypeQual (TSconst _) = True+isTypeQual (TSvolatile _) = True+isTypeQual (TSinline _) = True+isTypeQual (TSrestrict _) = True+isTypeQual (TSdevice _) = True+isTypeQual (TSglobal _) = True+isTypeQual (TShost _) = True+isTypeQual (TSconstant _) = True+isTypeQual (TSshared _) = True+isTypeQual (TSnoinline _) = True+isTypeQual _ = False++mkTypeQuals :: [TySpec] -> [TypeQual]+mkTypeQuals specs = map mk (filter isTypeQual specs)+ where+ mk :: TySpec -> TypeQual+ mk (TSconst loc) = Tconst loc+ mk (TSvolatile loc) = Tvolatile loc+ mk (TSinline loc) = Tinline loc+ mk (TSrestrict loc) = Trestrict loc+ mk (TSdevice loc) = Tdevice loc+ mk (TSglobal loc) = Tglobal loc+ mk (TShost loc) = Thost loc+ mk (TSconstant loc) = Tconstant loc+ mk (TSshared loc) = Tshared loc+ mk (TSnoinline loc) = Tnoinline loc+ mk _ = error "internal error in mkTypeQual"++isSign :: TySpec -> Bool+isSign (TSsigned _) = True+isSign (TSunsigned _) = True+isSign _ = False++hasSign :: [TySpec] -> Bool+hasSign specs = any isSign specs++mkSign :: [TySpec] -> P (Maybe Sign)+mkSign specs =+ case filter isSign specs of+ [] -> return Nothing+ [TSunsigned loc] -> return (Just (Tunsigned loc))+ [TSsigned loc] -> return (Just (Tsigned loc))+ [_] -> fail "internal error in mkSign"+ _ -> fail "multiple signs specified"++checkNoSign :: [TySpec] -> String -> P ()+checkNoSign spec msg | hasSign spec = fail msg+ | otherwise = return ()++composeDecls :: Decl -> Decl -> Decl+composeDecls (DeclRoot _) root =+ root++composeDecls (C.Ptr quals decl loc) root =+ C.Ptr quals (composeDecls decl root) loc++composeDecls (Array quals size decl loc) root =+ Array quals size (composeDecls decl root) loc++composeDecls (Proto decl args loc) root =+ Proto (composeDecls decl root) args loc++composeDecls (OldProto decl args loc) root =+ OldProto (composeDecls decl root) args loc++mkDeclSpec :: [TySpec] -> P DeclSpec+mkDeclSpec specs =+ go rest+ where+ storage ::[Storage]+ storage = mkStorage specs++ quals :: [TypeQual]+ quals = mkTypeQuals specs++ rest :: [TySpec]+ rest = [x | x <- specs+ , not (isStorage x) && not (isTypeQual x) && not (isSign x)]++ go :: [TySpec] -> P DeclSpec+ go [TSvoid loc] = do+ checkNoSign specs "sign specified for void type"+ return $ cdeclSpec storage quals (Tvoid loc)++ go [TSchar loc] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tchar sign loc)++ go [TSshort loc] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tshort sign loc)++ go [TSshort _, TSint _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tshort sign (locOf rest))++ go [TSint _, TSshort _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tshort sign (locOf rest))++ go [TSint loc] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tint sign loc)++ go [TSlong loc] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong sign loc)++ go [TSlong _, TSint _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong sign (locOf rest))++ go [TSint _, TSlong _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong sign (locOf rest))++ go [TSlong _, TSlong _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong_long sign (locOf rest))++ go [TSlong _, TSlong _, TSint _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong_long sign (locOf rest))++ go [TSlong _, TSint _, TSlong _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong_long sign (locOf rest))++ go [TSint _, TSlong _, TSlong _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong_long sign (locOf rest))++ go [TSfloat loc] = do+ checkNoSign specs "sign specified for float type"+ return $ cdeclSpec storage quals (Tfloat loc)++ go [TSdouble loc] = do+ checkNoSign specs "sign specified for double type"+ return $ cdeclSpec storage quals (Tdouble loc)++ go [TSlong _, TSdouble _] = do+ checkNoSign specs "sign specified for long double type"+ return $ cdeclSpec storage quals (Tlong_double (locOf rest))++ go [TSdouble _, TSlong _] = do+ checkNoSign specs "sign specified for long double type"+ return $ cdeclSpec storage quals (Tlong_double (locOf rest))++ go [TSstruct ident fields attrs loc] = do+ checkNoSign specs "sign specified for struct type"+ return $ cdeclSpec storage quals (Tstruct ident fields attrs loc)++ go [TSunion ident fields attrs loc] = do+ checkNoSign specs "sign specified for union type"+ return $ cdeclSpec storage quals (Tunion ident fields attrs loc)++ go [TSenum ident enums attrs loc] = do+ checkNoSign specs "sign specified for enum type"+ return $ cdeclSpec storage quals (Tenum ident enums attrs loc)++ go [TSnamed ident loc] = do+ checkNoSign specs "sign specified for named type"+ return $ cdeclSpec storage quals (Tnamed ident loc)++ go [TStypeofExp e loc] = do+ checkNoSign specs "sign specified for typeof"+ return $ cdeclSpec storage quals (TtypeofExp e loc)++ go [TStypeofType ty loc] = do+ checkNoSign specs "sign specified for typeof"+ return $ cdeclSpec storage quals (TtypeofType ty loc)++ go [TSva_list loc] = do+ checkNoSign specs "sign specified for __builtin_va_list"+ return $ cdeclSpec storage quals (Tva_list loc)++ go [] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tint sign (storage <--> quals))++ go tyspecs =+ throw $ ParserException loc+ (text "bad type:" <+> spread (map ppr tyspecs))+ where+ loc = getLoc tyspecs++mkPtr :: [TySpec] -> Decl -> Decl+mkPtr specs decl = C.Ptr quals decl (specs <--> decl)+ where+ quals = mkTypeQuals specs++mkArray :: [TySpec] -> ArraySize -> Decl -> Decl+mkArray specs size decl = Array quals size decl (specs <--> decl)+ where+ quals = mkTypeQuals specs++mkProto :: Params -> Decl -> Decl+mkProto args decl = Proto decl args (args <--> decl)++mkOldProto :: [Id] -> Decl -> Decl+mkOldProto args decl = OldProto decl args (args <--> decl)++checkInitGroup :: DeclSpec -> Decl -> [Attr] -> [Init] -> P InitGroup+checkInitGroup dspec decl attrs inits =+ go dspec+ where+ go :: DeclSpec -> P InitGroup+ go (DeclSpec storage quals tspec _) | any isTypedef storage = do+ typedefs <- mapM checkInit inits'+ let dspec' = cdeclSpec storage' quals tspec+ return $ ctypedefGroup dspec' attrs typedefs+ where+ storage' :: [Storage]+ storage' = [x | x <- storage, (not . isTypedef) x]++ isTypedef :: Storage -> Bool+ isTypedef (Ttypedef _) = True+ isTypedef _ = False++ checkInit :: Init -> P Typedef+ checkInit init@(Init ident _ _ (Just _) _ _)=+ throw $ ParserException (getLoc init) $+ text "typedef" <+>+ squotes (ppr ident) <+>+ text "is illegaly initialized"++ checkInit (Init ident@(Id name _) decl _ _ attrs _) = do+ addTypedef name+ return $ ctypedef ident decl attrs++ checkInit (Init ident@(AntiId _ _) decl _ _ attrs _) =+ return $ ctypedef ident decl attrs++ go _ = do+ mapM_ checkInit inits'+ return $ cinitGroup dspec attrs inits'+ where+ checkInit :: Init -> P ()+ checkInit (Init (Id name _) _ _ _ _ _) = addVariable name+ checkInit (Init (AntiId _ _) _ _ _ _ _) = return ()++ composeInitDecl :: Decl -> Init -> Init+ composeInitDecl decl (Init ident initDecl maybe_asmlabel maybe_exp attrs loc) =+ Init ident (composeDecls initDecl decl) maybe_asmlabel maybe_exp attrs loc++ inits' = map (composeInitDecl decl) inits++ loc :: Loc+ loc = (dspec <--> attrs :: Loc) <--> inits++declRoot :: Located a => a -> Decl+declRoot x = DeclRoot (locOf x)++data RevList a = RNil+ | RCons a (RevList a)++rnil :: RevList a+rnil = RNil++rsingleton :: a -> RevList a+rsingleton x = RCons x RNil++rcons :: a -> RevList a -> RevList a+rcons x xs = RCons x xs++rev :: RevList a -> [a]+rev xs = go [] xs+ where+ go l RNil = l+ go l (RCons x xs) = go (x : l) xs++expected :: Loc+ -> [String]+ -> P a+expected loc alts =+ throw $ ParserException (locEnd loc)+ (text "unclosed" <+> go alts)+ where+ go :: [String] -> Doc+ go [] = empty+ go [x] = text x+ go [x, y] = text x <+> text "or" <+> text y+ go (x : xs) = text x <> comma <+> go xs++unclosed :: Loc+ -> String+ -> P a+unclosed loc x =+ throw $ ParserException (locEnd loc)+ (text "unclosed" <+> squotes (text x))++badExecutionContext :: Loc+ -> [Exp]+ -> P a+badExecutionContext loc es =+ throw $ ParserException (locEnd loc) $+ text "execution context should have 2-4 arguments, but saw" <+>+ ppr (length es)++badFunctionDeclaration :: Loc+ -> [Exp]+ -> P a+badFunctionDeclaration loc es =+ throw $ ParserException (locEnd loc) $+ text "execution context should have 2-4 arguments, but saw" <+>+ ppr (length es)+}
+ Language/C/Parser/Tokens.hs view
@@ -0,0 +1,405 @@+-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Parser.Tokens+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Parser.Tokens (+ Token(..),+ ExtensionsInt,+ keywords,+ keywordMap+ ) where++import Data.Bits+import Data.List (foldl')+import qualified Data.Map as Map+import Data.Maybe (fromMaybe)+import Data.Word++import Language.C.Syntax (Extensions(..),+ Signed(..))++data Token = Teof+ | TintConst (String, Signed, Integer)+ | TlongIntConst (String, Signed, Integer)+ | TlongLongIntConst (String, Signed, Integer)+ | TfloatConst (String, Rational)+ | TdoubleConst (String, Rational)+ | TlongDoubleConst (String, Rational)+ | TcharConst (String, Char)+ | TstringConst (String, String)+ | Tidentifier String+ | Tnamed String+ | Tlparen+ | Trparen+ | Tlbrack+ | Trbrack+ | Tlbrace+ | Trbrace+ | Tcomma+ | Tsemi+ | Tcolon+ | Tquestion+ | Tdot+ | Tarrow+ | Tellipses++ | Tplus+ | Tminus+ | Tstar+ | Tdiv+ | Tmod+ | Tnot+ | Tand+ | Tor+ | Txor+ | Tlsh+ | Trsh+ | Tinc+ | Tdec++ | Tlnot+ | Tland+ | Tlor++ | Teq+ | Tne+ | Tlt+ | Tgt+ | Tle+ | Tge++ | Tassign+ | Tadd_assign+ | Tsub_assign+ | Tmul_assign+ | Tdiv_assign+ | Tmod_assign+ | Tlsh_assign+ | Trsh_assign+ | Tand_assign+ | Tor_assign+ | Txor_assign++ | Tauto+ | Tbreak+ | Tcase+ | Tchar+ | Tconst+ | Tcontinue+ | Tdefault+ | Tdo+ | Tdouble+ | Telse+ | Tenum+ | Textern+ | Tfloat+ | Tfor+ | Tgoto+ | Tif+ | Tinline+ | Tint+ | Tlong+ | Tregister+ | Trestrict+ | Treturn+ | Tshort+ | Tsigned+ | Tsizeof+ | Tstatic+ | Tstruct+ | Tswitch+ | Ttypedef+ | Tunion+ | Tunsigned+ | Tvoid+ | Tvolatile+ | Twhile+ | TBool+ | TComplex+ | TImaginary++ -- GCC+ | Tasm+ | Tattribute+ | Tbuiltin_va_arg+ | Tbuiltin_va_list+ | Textension+ | Ttypeof++ -- CUDA+ | T3lt+ | T3gt+ | Tdevice+ | Tglobal+ | Thost+ | Tconstant+ | Tshared+ | Tnoinline++ -- Antiquoting+ | Ttypename++ | Tanti_id String+ | Tanti_int String+ | Tanti_uint String+ | Tanti_lint String+ | Tanti_ulint String+ | Tanti_float String+ | Tanti_double String+ | Tanti_long_double String+ | Tanti_char String+ | Tanti_string String+ | Tanti_exp String+ | Tanti_func String+ | Tanti_args String+ | Tanti_decl String+ | Tanti_decls String+ | Tanti_sdecl String+ | Tanti_sdecls String+ | Tanti_enum String+ | Tanti_enums String+ | Tanti_esc String+ | Tanti_edecl String+ | Tanti_edecls String+ | Tanti_item String+ | Tanti_items String+ | Tanti_stm String+ | Tanti_stms String+ | Tanti_type String+ | Tanti_spec String+ | Tanti_param String+ | Tanti_params String+ deriving (Ord, Eq)++instance Show Token where+ show Teof = "EOF"+ show (TintConst (s, _, _)) = s+ show (TlongIntConst (s, _, _)) = s+ show (TlongLongIntConst (s, _, _)) = s+ show (TfloatConst (s, _)) = s+ show (TdoubleConst (s, _)) = s+ show (TlongDoubleConst (s, _)) = s+ show (TcharConst (s, _)) = s+ show (TstringConst (s, _)) = s+ show (Tidentifier s) = "identifier: " ++ show s+ show t = fromMaybe (error "internal error: unknown token")+ (lookup t tokenStrings)++tokenStrings :: [(Token, String)]+tokenStrings = [(Tlparen, "("),+ (Trparen, ")"),+ (Tlbrack, "["),+ (Trbrack, "]"),+ (Tlbrace, "{"),+ (Trbrace, "}"),+ (Tcomma, ","),+ (Tsemi, ";"),+ (Tcolon, ":"),+ (Tquestion, "?"),+ (Tdot, "."),+ (Tarrow, "->"),+ (Tellipses, "..."),+ (Tplus, "+"),+ (Tminus, "-"),+ (Tstar, "*"),+ (Tdiv, "/"),+ (Tmod, "%"),+ (Tnot, "~"),+ (Tand, "&"),+ (Tor, "|"),+ (Txor, "^"),+ (Tlsh, "<<"),+ (Trsh, ">>"),+ (Tinc, "++"),+ (Tdec, "--"),+ (Tlnot, "!"),+ (Tland, "&&"),+ (Tlor, "||"),+ (Teq, "=="),+ (Tne, "!="),+ (Tlt, "<"),+ (Tgt, ">"),+ (Tle, "<="),+ (Tge, ">="),+ (Tassign, "="),+ (Tadd_assign, "+="),+ (Tsub_assign, "-="),+ (Tmul_assign, "*="),+ (Tdiv_assign, "/="),+ (Tmod_assign, "%="),+ (Tlsh_assign, "<<="),+ (Trsh_assign, ">>="),+ (Tand_assign, "&="),+ (Tor_assign, "|="),+ (Txor_assign, "^="),++ --+ -- Keywords+ --+ (Tauto, "auto"),+ (Tbreak, "break"),+ (Tcase, "case"),+ (Tchar, "char"),+ (Tconst, "const"),+ (Tcontinue, "continue"),+ (Tdefault, "default"),+ (Tdo, "do"),+ (Tdouble, "double"),+ (Telse, "else"),+ (Tenum, "enum"),+ (Textern, "extern"),+ (Tfloat, "float"),+ (Tfor, "for"),+ (Tgoto, "goto"),+ (Tif, "if"),+ (Tinline, "inline"),+ (Tint, "int"),+ (Tlong, "long"),+ (Tregister, "register"),+ (Trestrict, "restrict"),+ (Treturn, "return"),+ (Tshort, "short"),+ (Tsigned, "signed"),+ (Tsizeof, "sizeof"),+ (Tstatic, "static"),+ (Tstruct, "struct"),+ (Tswitch, "switch"),+ (Ttypedef, "typedef"),+ (Tunion, "union"),+ (Tunsigned, "unsigned"),+ (Tvoid, "void"),+ (Tvolatile, "volatile"),+ (Twhile, "while"),+ (TBool, "_Bool"),+ (TComplex, "_TComplex"),+ (TImaginary, "_TImaginary"),++ --+ -- GCC extensions+ --+ (Tasm, "asm"),+ (Tattribute, "__attribute__"),+ (Tbuiltin_va_arg, "__builtin_va_arg"),+ (Tbuiltin_va_list, "__builtin_va_list"),+ (Textension, "__extension__"),+ (Ttypeof, "typeof"),++ --+ -- CUDA extensions+ --+ (Tdevice, "__device__"),+ (Tglobal, "__global__"),+ (Thost, "__host__"),+ (Tconstant, "__constant__"),+ (Tshared, "__shared__"),+ (Tnoinline, "__noinline__")+ ]++keywords :: [(String, Token, Maybe [Extensions])]+keywords = [("auto", Tauto, Nothing),+ ("break", Tbreak, Nothing),+ ("case", Tcase, Nothing),+ ("char", Tchar, Nothing),+ ("const", Tconst, Nothing),+ ("continue", Tcontinue, Nothing),+ ("default", Tdefault, Nothing),+ ("do", Tdo, Nothing),+ ("double", Tdouble, Nothing),+ ("else", Telse, Nothing),+ ("enum", Tenum, Nothing),+ ("extern", Textern, Nothing),+ ("float", Tfloat, Nothing),+ ("for", Tfor, Nothing),+ ("goto", Tgoto, Nothing),+ ("if", Tif, Nothing),+ ("inline", Tinline, Nothing),+ ("int", Tint, Nothing),+ ("long", Tlong, Nothing),+ ("register", Tregister, Nothing),+ ("restrict", Trestrict, Nothing),+ ("return", Treturn, Nothing),+ ("short", Tshort, Nothing),+ ("signed", Tsigned, Nothing),+ ("sizeof", Tsizeof, Nothing),+ ("static", Tstatic, Nothing),+ ("struct", Tstruct, Nothing),+ ("switch", Tswitch, Nothing),+ ("typedef", Ttypedef, Nothing),+ ("union", Tunion, Nothing),+ ("unsigned", Tunsigned, Nothing),+ ("void", Tvoid, Nothing),+ ("volatile", Tvolatile, Nothing),+ ("while", Twhile, Nothing),+ ("_Bool", TBool, Nothing),+ ("_Complex", TComplex, Nothing),+ ("_Imaginary", TImaginary, Nothing),++ ("asm", Tasm, Just [Gcc]),+ ("__asm", Tasm, Just [Gcc]),+ ("__asm__", Tasm, Just [Gcc]),+ ("__attribute__", Tattribute, Just [Gcc]),+ ("__builtin_va_arg", Tbuiltin_va_arg, Just [Gcc]),+ ("__builtin_va_list", Tbuiltin_va_list, Just [Gcc]),+ ("__const", Tconst, Just [Gcc]),+ ("__const__", Tconst, Just [Gcc]),+ ("__inline", Tinline, Just [Gcc]),+ ("__inline__", Tinline, Just [Gcc]),+ ("__restrict", Trestrict, Just [Gcc]),+ ("__restrict__", Trestrict, Just [Gcc]),+ ("typeof", Ttypeof, Just [Gcc]),+ ("__typeof", Ttypeof, Just [Gcc]),+ ("__typeof__", Ttypeof, Just [Gcc]),+ ("__volatile", Tvolatile, Just [Gcc]),+ ("__volatile__", Tvolatile, Just [Gcc]),++ ("__device__", Tdevice, Just [CUDA]),+ ("__global__", Tglobal, Just [CUDA]),+ ("__host__", Thost, Just [CUDA]),+ ("__constant__", Tconstant, Just [CUDA]),+ ("__shared__", Tshared, Just [CUDA]),+ ("__noinline__", Tnoinline, Just [CUDA])+ ]++type ExtensionsInt = Word32++keywordMap :: Map.Map String (Token, Maybe ExtensionsInt)+keywordMap = Map.fromList (map f keywords)+ where+ f :: (String, Token, Maybe [Extensions])+ -> (String, (Token, Maybe ExtensionsInt))+ f (s, t, Nothing) = (s, (t, Nothing))+ f (s, t, Just exts) = (s, (t, Just i))+ where+ i = foldl' setBit 0 (map fromEnum exts)
+ Language/C/Pretty.hs view
@@ -0,0 +1,735 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleInstances #-}++-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Pretty+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Pretty where++import Data.Loc+import Language.C.Syntax+import Text.PrettyPrint.Mainland++pprLoc :: SrcLoc -> Doc -> Doc+pprLoc loc doc = srcloc loc <> doc++data Fixity = Fixity Assoc Int+ deriving (Eq, Ord)++data Assoc = LeftAssoc | RightAssoc | NonAssoc+ deriving (Eq, Ord)++infix_ :: Int -> Fixity+infix_ = Fixity NonAssoc++infixl_ :: Int -> Fixity+infixl_ = Fixity LeftAssoc++infixr_ :: Int -> Fixity+infixr_ = Fixity RightAssoc++infixop :: (Pretty a, Pretty b, Pretty op, CFixity op)+ => Int -- ^ precedence of context+ -> op -- ^ operator+ -> a -- ^ left argument+ -> b -- ^ right argument+ -> Doc+infixop prec op l r =+ parensIf (prec > opPrec) $+ pprPrec leftPrec l <+> ppr op <+/> pprPrec rightPrec r+ where+ leftPrec | opAssoc == RightAssoc = opPrec + 1+ | otherwise = opPrec++ rightPrec | opAssoc == LeftAssoc = opPrec + 1+ | otherwise = opPrec++ Fixity opAssoc opPrec = fixity op++parensList :: [Doc] -> Doc+parensList = encloseSep lparen rparen comma++bracesList :: [Doc] -> Doc+bracesList = encloseSep lbrace rbrace comma++bracesSemiList :: [Doc] -> Doc+bracesSemiList = encloseSep lbrace rbrace semi++class CFixity a where+ fixity :: a -> Fixity++-- Fixities are taken from Table 2-1 in Section 2.12 of K&R (2nd ed.)++instance CFixity BinOp where+ fixity Add = infixl_ 12+ fixity Sub = infixl_ 12+ fixity Mul = infixl_ 13+ fixity Div = infixl_ 13+ fixity Mod = infixl_ 13+ fixity Eq = infixl_ 9+ fixity Ne = infixl_ 9+ fixity Lt = infixl_ 10+ fixity Gt = infixl_ 10+ fixity Le = infixl_ 10+ fixity Ge = infixl_ 10+ fixity Land = infixl_ 5+ fixity Lor = infixl_ 4+ fixity And = infixl_ 8+ fixity Or = infixl_ 6+ fixity Xor = infixl_ 7+ fixity Lsh = infixl_ 11+ fixity Rsh = infixl_ 11++instance CFixity AssignOp where+ fixity _ = infixr_ 2++instance CFixity UnOp where+ fixity _ = infixr_ 14++instance Pretty Id where+ ppr (Id ident _) = text ident+ ppr (AntiId v _) = ppr "$id:" <> ppr v++instance Pretty Storage where+ ppr (Tauto _) = text "auto"+ ppr (Tregister _) = text "register"+ ppr (Tstatic _) = text "static"+ ppr (Textern _) = text "extern"+ ppr (TexternL l _) = text "extern" <+> ppr l+ ppr (Ttypedef _) = text "typedef"++instance Pretty TypeQual where+ ppr (Tconst _) = text "const"+ ppr (Tvolatile _) = text "volatile"+ ppr (Tinline _) = text "inline"++ ppr (Trestrict _) = text "__restrict"++ ppr (Tdevice _) = text "__device__"+ ppr (Tglobal _) = text "__global__"+ ppr (Thost _) = text "__host__"+ ppr (Tconstant _) = text "__constant__"+ ppr (Tshared _) = text "__shared__"+ ppr (Tnoinline _) = text "__noinline__"++instance Pretty Sign where+ ppr (Tsigned _) = text "signed"+ ppr (Tunsigned _) = text "unsigned"++pprSign :: Maybe Sign -> Doc+pprSign Nothing = empty+pprSign (Just sign) = ppr sign <> space++instance Pretty TypeSpec where+ ppr (Tvoid _) = text "void"+ ppr (Tchar sign _) = pprSign sign <> text "char"+ ppr (Tshort sign _) = pprSign sign <> text "short"+ ppr (Tint sign _) = pprSign sign <> text "int"+ ppr (Tlong sign _) = pprSign sign <> text "long"+ ppr (Tlong_long sign _) = pprSign sign <> text "long long"+ ppr (Tfloat _) = text "float"+ ppr (Tdouble _) = text "double"+ ppr (Tlong_double _) = text "long double"++ ppr (Tstruct maybe_ident maybe_fields attrs _) =+ pprStructOrUnion "struct" maybe_ident maybe_fields attrs++ ppr (Tunion maybe_ident maybe_fields attrs _) =+ pprStructOrUnion "union" maybe_ident maybe_fields attrs++ ppr (Tenum maybe_ident cenums attrs _) =+ pprEnum maybe_ident cenums attrs++ ppr (Tnamed ident _) =+ ppr ident++ ppr (TtypeofExp e _) =+ text "__typeof__" <> parens (pprPrec 14 e)++ ppr (TtypeofType tipe _) =+ text "__typeof__" <> parens (ppr tipe)++ ppr (Tva_list _) =+ text "__builtin_va_list"++pprStructOrUnion :: String+ -> Maybe Id+ -> Maybe [FieldGroup]+ -> [Attr]+ -> Doc+pprStructOrUnion ty maybe_ident maybe_fields attrs =+ text ty+ <> case maybe_ident of+ Nothing -> empty+ Just ident -> space <> ppr ident+ <> case maybe_fields of+ Nothing -> empty+ Just fields -> space <> lbrace+ <> nest 4 (line <> stack (zipWith (<>) (map ppr fields) (repeat semi)))+ </> rbrace+ <> case attrs of+ [] -> empty+ _ -> softline <> ppr attrs++pprEnum :: Maybe Id+ -> [CEnum]+ -> [Attr]+ -> Doc+pprEnum maybe_ident cenums attrs =+ text "enum"+ <> case maybe_ident of+ Nothing -> empty+ Just ident -> space <> ppr ident+ <> case cenums of+ [] -> empty+ _ -> space <> lbrace <>+ nest 4 (line <> stack (punctuate comma (map ppr cenums))) </>+ rbrace+ <> case attrs of+ [] -> empty+ _ -> softline <> ppr attrs++instance Pretty DeclSpec where+ ppr (DeclSpec storage quals spec _) =+ case map ppr storage ++ map ppr quals of+ [] -> ppr spec+ docs -> spread docs <+/> ppr spec++ ppr (AntiDeclSpec v _) =+ ppr "$spec:" <> ppr v++ ppr (AntiTypeDeclSpec storage quals v _) =+ spread (map ppr storage ++ map ppr quals) <+/>+ ppr "$ty:" <> ppr v++instance Pretty ArraySize where+ ppr (ArraySize True e _) = text "static" <+> ppr e+ ppr (ArraySize False e _) = ppr e+ ppr (VariableArraySize _) = text "*"+ ppr (NoArraySize _) = empty++pprDeclarator :: Maybe Id -> Decl -> Doc+pprDeclarator maybe_ident declarator =+ case maybe_ident of+ Nothing -> pprDecl declarator empty+ Just ident -> pprDecl declarator (space <> ppr ident)+ where+ pprPtr :: Decl -> Doc -> (Decl, Doc)+ pprPtr (Ptr [] decl _) post =+ pprPtr decl $+ text "*" <> post+ pprPtr (Ptr quals decl _) post =+ pprPtr decl $+ text "*" <> spread (map ppr quals) <+> post+ pprPtr decl post = (decl, post)++ pprDirDecl :: Decl -> Doc -> (Decl, Doc)+ pprDirDecl (Array [] size decl _) pre =+ pprDirDecl decl $+ pre <> brackets (align (ppr size))++ pprDirDecl (Array quals size decl _) pre =+ pprDirDecl decl $+ pre <> brackets (align (spread (map ppr quals) <> ppr size))++ pprDirDecl (Proto decl args _) pre =+ pprDirDecl decl $+ pre <> parens (ppr args)++ pprDirDecl (OldProto decl args _) pre =+ pprDirDecl decl $+ pre <> parensList (map ppr args)++ pprDirDecl decl pre = (decl, pre)++ pprDecl :: Decl -> Doc -> Doc+ pprDecl decl mid =+ case decl' of+ DeclRoot _ -> declDoc+ _ -> pprDecl decl' (parens declDoc)+ where+ (decl', declDoc) = uncurry pprPtr (pprDirDecl decl mid)++instance Pretty Type where+ ppr (Type spec decl _) = ppr spec <> pprDeclarator Nothing decl+ ppr (AntiType v _) = ppr "$ty:" <> ppr v++instance Pretty Designator where+ ppr (IndexDesignator e _) = brackets $ ppr e+ ppr (MemberDesignator ident _) = dot <> ppr ident++instance Pretty Designation where+ ppr (Designation ds _) = folddoc (<>) (map ppr ds)++instance Pretty Initializer where+ ppr (ExpInitializer e _) = ppr e++ ppr (CompoundInitializer inits _) =+ bracesList (map pprInit inits)+ where+ pprInit :: (Maybe Designation, Initializer) -> Doc+ pprInit (Nothing, init) = ppr init+ pprInit (Just d, init) = ppr d <+> text "=" <//> ppr init++instance Pretty Init where+ ppr (Init ident decl maybe_asmlabel maybe_e attrs _) =+ pprDeclarator (Just ident) decl+ <> case maybe_asmlabel of+ Nothing -> empty+ Just l -> space <> text "asm" <+> parens (text l)+ <> case maybe_e of+ Nothing -> empty+ Just e -> space <> text "=" <+/> ppr e+ <> case attrs of+ [] -> empty+ _ -> softline <> ppr attrs++instance Pretty Typedef where+ ppr (Typedef ident decl attrs loc) =+ ppr (Init ident decl Nothing Nothing attrs loc)++instance Pretty InitGroup where+ ppr (InitGroup spec attrs inits _) =+ ppr spec+ <> case attrs of+ [] -> empty+ _ -> softline <> ppr attrs+ <> case inits of+ [] -> empty+ _ -> commasep (map ppr inits)++ ppr (TypedefGroup spec attrs typedefs _) =+ text "typedef" <+> ppr spec+ <> case attrs of+ [] -> empty+ _ -> softline <> ppr attrs+ <> case typedefs of+ [] -> empty+ _ -> commasep (map ppr typedefs)++ ppr (AntiDecls v _) = ppr "$decls:" <> ppr v+ ppr (AntiDecl v _) = ppr "$decl:" <> ppr v++instance Pretty Field where+ ppr (Field maybe_ident maybe_decl maybe_e _) =+ case maybe_decl of+ Nothing -> empty+ Just decl -> pprDeclarator maybe_ident decl+ <> case maybe_e of+ Nothing -> empty+ Just e -> space <> colon <+> ppr e++instance Pretty FieldGroup where+ ppr (FieldGroup spec fields _) =+ ppr spec <> commasep (map ppr fields)++ ppr (AntiSdecls v _) = ppr "$sdecls:" <> ppr v+ ppr (AntiSdecl v _) = ppr "$sdecl:" <> ppr v++instance Pretty CEnum where+ ppr (CEnum ident maybe_e _) =+ ppr ident+ <> case maybe_e of+ Nothing -> empty+ Just e -> space <> text "=" <+/> ppr e++ ppr (AntiEnums v _) = ppr "$enums:" <> ppr v+ ppr (AntiEnum v _) = ppr "$enum:" <> ppr v++instance Pretty Attr where+ ppr (Attr ident [] _) = ppr ident+ ppr (Attr ident args _) =+ ppr ident <> parens (commasep (map ppr args))++ pprList [] = empty+ pprList attrs = text "__attribute__" <>+ parens (parens (commasep (map ppr attrs)))++instance Pretty Param where+ ppr (Param maybe_ident spec decl _) =+ ppr spec <> pprDeclarator maybe_ident decl++ ppr (AntiParams v _) = ppr "$params:" <> ppr v+ ppr (AntiParam v _) = ppr "$param:" <> ppr v++instance Pretty Params where+ ppr (Params args True _) =+ commasep (map ppr args ++ [text "..."])++ ppr (Params args False _) =+ commasep (map ppr args)++instance Pretty Func where+ ppr (Func spec ident decl args body loc) =+ ppr spec <> pprDeclarator (Just ident) (Proto decl args loc)+ </> ppr body++ ppr (OldFunc spec ident decl args maybe_initgroups body loc) =+ ppr spec <> pprDeclarator (Just ident) (OldProto decl args loc)+ </> case maybe_initgroups of+ Nothing -> empty+ Just initgroups ->+ stack (zipWith (<>) (map ppr initgroups) (repeat semi))+ </> ppr body++instance Pretty Definition where+ ppr (FuncDef func loc) = srcloc loc <> ppr func+ ppr (DecDef initgroup loc) = srcloc loc <> ppr initgroup <> semi+ ppr (EscDef s loc) = srcloc loc <> text s++ ppr (AntiFunc v _) = ppr "$func:" <> ppr v+ ppr (AntiEsc v _) = ppr "$esc:" <> ppr v+ ppr (AntiEdecls v _) = ppr "$edecls:" <> ppr v+ ppr (AntiEdecl v _) = ppr "$edecl:" <> ppr v++ pprList ds = stack (map ppr ds) <> line++instance Pretty Stm where+ ppr (Label ident stm sloc) =+ srcloc sloc <>+ nest (-2) (line <> ppr ident <+> colon </> ppr stm)++ ppr (Case e stm sloc) =+ srcloc sloc <>+ nest (-2) (line <> text "case" <+> ppr e <> colon) </> ppr stm++ ppr (Default stm sloc) =+ srcloc sloc <>+ nest (-2) (line <> text "default:") </> ppr stm++ ppr (Exp Nothing sloc) =+ srcloc sloc <> semi++ ppr (Exp (Just e) sloc) =+ srcloc sloc <> hang 4 (ppr e) <> semi++ ppr (Block items sloc) =+ srcloc sloc <> ppr items++ ppr (If test then' maybe_else sloc) =+ srcloc sloc <>+ text "if" <+> parens (ppr test)+ <> pprStm then'+ <> case maybe_else of+ Nothing -> empty+ Just else' -> space <> text "else" <> pprStm else'+ where+ pprStm :: Stm -> Doc+ pprStm stm@(Block _ _) = space <> ppr stm+ pprStm stm@(If _ _ _ _) = space <> ppr stm+ pprStm stm = nest 4 (line <> ppr stm) <> line++ ppr (Switch e stm sloc) =+ srcloc sloc <>+ text "switch" <+> parens (ppr e ) <+/> ppr stm++ ppr (While e stm sloc) =+ srcloc sloc <>+ text "while" <+> parens (ppr e) <+/> ppr stm++ ppr (DoWhile stm e sloc) =+ srcloc sloc <>+ text "do" <+/> ppr stm <+/> text "while" <> parens(ppr e) <> semi++ ppr (For ini test post stm sloc) =+ srcloc sloc <>+ text "for"+ <+> (parens . semisep) [either ppr ppr ini, ppr test, ppr post]+ <> case stm of+ Block {} -> space <> ppr stm+ _ -> nest 4 $ line <> ppr stm++ ppr (Goto ident sloc) =+ srcloc sloc <>+ text "goto" <+> ppr ident <> semi++ ppr (Continue sloc) =+ srcloc sloc <> text "continue" <>semi++ ppr (Break sloc) =+ srcloc sloc <> text "break" <> semi++ ppr (Return Nothing sloc) =+ srcloc sloc <> text "return" <> semi++ ppr (Return (Just e) sloc) =+ srcloc sloc <> nest 4 (text "return" <+> ppr e) <> semi++ ppr (Asm isVolatile _ template outputs inputs clobbered sloc) =+ srcloc sloc <>+ text "__asm__"+ <> case isVolatile of+ True -> space <> text "__volatile__"+ False -> empty+ <> parens (pprAsm inputs clobbered)+ <> semi+ where+ pprAsm :: [(String, Exp)] -> [String] -> Doc+ pprAsm [] [] =+ spread (map text template)+ <> case outputs of+ [] -> space <> colon+ _ -> colon <+/> commasep (map pprReg outputs)++ pprAsm inputs clobbered =+ spread (map text template)+ <> case outputs of+ [] -> space <> colon+ _ -> colon <+/> commasep (map pprReg outputs)+ <> case inputs of+ [] -> space <> colon+ _ -> colon <+/> commasep (map pprReg inputs)+ <> case clobbered of+ [] -> space <> colon+ _ -> colon <+/> commasep (map text clobbered)++ pprReg :: (String, Exp) -> Doc+ pprReg (reg, e) = text reg <+> parens (ppr e)++ ppr (AntiStm v _) = text $ "$stm:" ++ v ++ "$"+ ppr (AntiStms v _) = text $ "$stms:" ++ v ++ "$"++instance Pretty BlockItem where+ ppr (BlockDecl decl) = ppr decl <> semi+ ppr (BlockStm stm) = ppr stm++ ppr (AntiBlockItem v _) = text $ "$item:" ++ v ++ "$"+ ppr (AntiBlockItems v _) = text $ "$items:" ++ v ++ "$"++ pprList = embrace . loop+ where+ loop :: [BlockItem] -> [Doc]+ loop [] =+ []+ loop [item] =+ [ppr item]+ loop (item1@(BlockDecl _) : item2@(BlockStm _) : items) =+ (ppr item1 <> line) : loop (item2 : items)+ loop (item1@(BlockStm _) : item2@(BlockDecl _) : items) =+ (ppr item1 <> line) : loop (item2 : items)+ loop (item : items) =+ ppr item : loop items++ embrace :: [Doc] -> Doc+ embrace [] = lbrace <+> rbrace+ embrace ds = lbrace <>+ nest 4 (line <> stack ds) </>+ rbrace++instance Pretty Const where+ ppr (IntConst s _ _ _) = text s+ ppr (LongIntConst s _ _ _) = text s+ ppr (LongLongIntConst s _ _ _) = text s+ ppr (FloatConst s _ _) = text s+ ppr (DoubleConst s _ _) = text s+ ppr (LongDoubleConst s _ _) = text s+ ppr (CharConst s _ _) = text s+ ppr (StringConst ss _ _) = sep (map string ss)++ ppr (AntiString v _) = ppr "$string:" <> ppr v+ ppr (AntiChar v _) = ppr "$char:" <> ppr v+ ppr (AntiLongDouble v _) = ppr "$ldouble:" <> ppr v+ ppr (AntiDouble v _) = ppr "$double:" <> ppr v+ ppr (AntiFloat v _) = ppr "$float:" <> ppr v+ ppr (AntiULInt v _) = ppr "$ulint:" <> ppr v+ ppr (AntiLInt v _) = ppr "$lint:" <> ppr v+ ppr (AntiUInt v _) = ppr "$uint:" <> ppr v+ ppr (AntiInt v _) = ppr "$int:" <> ppr v++instance Pretty Exp where+ pprPrec _ (Var ident loc) = pprLoc loc $ ppr ident+ pprPrec _ (Const k loc) = pprLoc loc $ ppr k++ pprPrec p (BinOp op e1 e2 loc) =+ pprLoc loc $+ infixop p op e1 e2++ pprPrec p (Assign e1 op e2 loc) =+ pprLoc loc $+ infixop p op e1 e2++ pprPrec p (PreInc e loc) =+ pprLoc loc $+ parensIf (p > 14) $+ text "++" <> pprPrec 14 e++ pprPrec p (PostInc e loc) =+ pprLoc loc $+ parensIf (p > 15) $+ pprPrec 15 e <> text "++"++ pprPrec p (PreDec e loc) =+ pprLoc loc $+ parensIf (p > 14) $+ text "--" <> pprPrec 14 e++ pprPrec p (PostDec e loc) =+ pprLoc loc $+ parensIf (p > 15) $+ pprPrec 15 e <> text "--"++ pprPrec p (UnOp op e loc) =+ pprLoc loc $+ parensIf (p > 14) $+ ppr op <> pprPrec 14 e++ pprPrec p (SizeofExp e loc) =+ pprLoc loc $+ parensIf (p > 14) $+ text "sizeof" <> parens (pprPrec 14 e)++ pprPrec p (SizeofType tipe loc) =+ pprLoc loc $+ parensIf (p > 14) $+ text "sizeof" <> parens (ppr tipe)++ pprPrec p (Cast tipe e loc) =+ pprLoc loc $+ parensIf (p > 14) $+ parens (ppr tipe) <+> pprPrec 14 e++ pprPrec p (Cond test then' else' loc) =+ pprLoc loc $+ parensIf (p > 3) $+ pprPrec 3 test <+> text "?" <+>+ pprPrec 3 then' <+> colon <+> pprPrec 3 else'++ pprPrec p (Member e ident loc) =+ pprLoc loc $+ parensIf (p > 15) $+ pprPrec 15 e <> dot <> ppr ident++ pprPrec p (PtrMember e ident loc) =+ pprLoc loc $+ parensIf (p > 15) $+ pprPrec 15 e <> text "->" <> ppr ident++ pprPrec p (Index e1 e2 loc) =+ pprLoc loc $+ parensIf (p > 15) $+ pprPrec 15 e1 <> brackets (ppr e2)++ pprPrec p (FnCall f args loc) =+ pprLoc loc $+ parensIf (p > 15) $+ pprPrec 15 f <> parensList (map ppr args)++ pprPrec p (CudaCall f conf args loc) =+ pprLoc loc $+ parensIf (p > 15) $+ pprPrec 15 f <>+ text "<<<" <> pprConfig conf <> text ">>>" <>+ parensList (map ppr args)+ where+ pprConfig :: ExeConfig -> Doc+ pprConfig conf = commasep $+ [ppr (exeGridDim conf), ppr (exeBlockDim conf)] +++ (case exeSharedSize conf of+ Nothing -> []+ Just e -> [ppr e])+ +++ (case exeStream conf of+ Nothing -> []+ Just e -> [ppr e])++ pprPrec p (Seq e1 e2 loc) =+ pprLoc loc $+ parensIf (p > 1) $+ pprPrec 1 e1 <> comma <+/> pprPrec 1 e2++ pprPrec p (CompoundLit ty inits loc) =+ pprLoc loc $+ parensIf (p > 15) $+ parens (ppr ty) <+>+ braces (commasep (map pprInit inits))+ where+ pprInit :: (Maybe Designation, Initializer) -> Doc+ pprInit (Nothing, init) = ppr init+ pprInit (Just d, init) = ppr d <+> text "=" <+/> ppr init++ pprPrec _ (StmExpr blockItems loc) =+ pprLoc loc $ parens $+ ppr blockItems++ pprPrec _ (BuiltinVaArg e ty loc) =+ pprLoc loc $+ text "__builtin_va_arg(" <> ppr e <> comma <+> ppr ty <> rparen++ pprPrec _ (AntiArgs v _) = text "$args:" <> text v++ pprPrec _ (AntiExp v _) = text "$var:" <> text v++instance Pretty BinOp where+ ppr Add = text "+"+ ppr Sub = text "-"+ ppr Mul = text "*"+ ppr Div = text "/"+ ppr Mod = text "%"+ ppr Eq = text "=="+ ppr Ne = text "!="+ ppr Lt = text "<"+ ppr Gt = text ">"+ ppr Le = text "<="+ ppr Ge = text ">="+ ppr Land = text "&&"+ ppr Lor = text "||"+ ppr And = text "&"+ ppr Or = text "|"+ ppr Xor = text "^"+ ppr Lsh = text "<<"+ ppr Rsh = text ">>"++instance Pretty AssignOp where+ ppr JustAssign = text "="+ ppr AddAssign = text "+="+ ppr SubAssign = text "-="+ ppr MulAssign = text "*="+ ppr DivAssign = text "/="+ ppr ModAssign = text "%="+ ppr LshAssign = text "<<="+ ppr RshAssign = text ">>="+ ppr AndAssign = text "&="+ ppr XorAssign = text "^="+ ppr OrAssign = text "|="++instance Pretty UnOp where+ ppr AddrOf = text "&"+ ppr Deref = text "*"+ ppr Positive = text "+"+ ppr Negate = text "-"+ ppr Not = text "~"+ ppr Lnot = text "!"
+ Language/C/Quote/Base.hs view
@@ -0,0 +1,567 @@+-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Quote+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE TemplateHaskell #-}++module Language.C.Quote.Base (+ ToExp(..),+ quasiquote+ ) where++import Control.Monad ((>=>))+import qualified Data.ByteString.Char8 as B+import Data.Generics+import Data.Loc+import Data.Symbol+import Language.Haskell.Meta (parseExp, parsePat)+import Language.Haskell.TH+import Language.Haskell.TH.Quote (QuasiQuoter(..))++import qualified Language.C.Parser as P+import qualified Language.C.Syntax as C++class ToExp a where+ toExp :: a -> C.Exp++instance ToExp C.Exp where+ toExp = id++instance ToExp Int where+ toExp n = C.Const (C.IntConst (show n) C.Signed (fromIntegral n) noSrcLoc) noSrcLoc++instance ToExp Integer where+ toExp n = C.Const (C.IntConst (show n) C.Signed n noSrcLoc) noSrcLoc++instance ToExp Rational where+ toExp n = C.Const (C.DoubleConst (show n) n noSrcLoc) noSrcLoc++instance ToExp Float where+ toExp n = C.Const (C.DoubleConst (show n) (toRational n) noSrcLoc) noSrcLoc++instance ToExp Double where+ toExp n = C.Const (C.DoubleConst (show n) (toRational n) noSrcLoc) noSrcLoc++instance ToExp Char where+ toExp c = C.Const (C.CharConst (show c) c noSrcLoc) noSrcLoc++instance ToExp String where+ toExp s = C.Const (C.StringConst [show s] s noSrcLoc) noSrcLoc++antiVarE :: String -> ExpQ+antiVarE = either fail return . parseExp++qqLocE :: SrcLoc -> ExpQ+qqLocE loc = dataToExpQ qqExp loc++qqStringE :: String -> Maybe (Q Exp)+qqStringE s = Just $ litE $ stringL s++qqIdE :: C.Id -> Maybe (Q Exp)+qqIdE (C.AntiId v loc) = Just [|C.Id $(antiVarE v) $(qqLocE loc)|]+qqIdE _ = Nothing++qqDeclSpecE :: C.DeclSpec -> Maybe (Q Exp)+qqDeclSpecE (C.AntiDeclSpec v _) = Just $ antiVarE v+qqDeclSpecE (C.AntiTypeDeclSpec extraStorage extraTypeQuals v _) =+ Just [|let C.Type (C.DeclSpec storage typeQuals typeSpec loc) _ _+ = $(antiVarE v)+ in+ C.DeclSpec (storage ++ $(dataToExpQ qqExp extraStorage))+ (typeQuals ++ $(dataToExpQ qqExp extraTypeQuals))+ typeSpec+ loc+ |]+qqDeclSpecE _ = Nothing++qqDeclE :: C.Decl -> Maybe (Q Exp)+qqDeclE (C.AntiTypeDecl v _) =+ Just [|let C.Type _ decl _ = $(antiVarE v) in decl|]+qqDeclE _ = Nothing++qqTypeE :: C.Type -> Maybe (Q Exp)+qqTypeE (C.AntiType v _) = Just $ antiVarE v+qqTypeE _ = Nothing++qqInitGroupE :: C.InitGroup -> Maybe (Q Exp)+qqInitGroupE (C.AntiDecl v _) = Just $ antiVarE v+qqInitGroupE _ = Nothing++qqInitGroupListE :: [C.InitGroup] -> Maybe (Q Exp)+qqInitGroupListE [] = Just [|[]|]+qqInitGroupListE (C.AntiDecls v _ : inis) =+ Just [|$(antiVarE v) ++ $(dataToExpQ qqExp inis)|]+qqInitGroupListE (ini : inis) =+ Just [|$(dataToExpQ qqExp ini) : $(dataToExpQ qqExp inis)|]++qqFieldGroupE :: C.FieldGroup -> Maybe (Q Exp)+qqFieldGroupE (C.AntiSdecl v _) = Just $ antiVarE v+qqFieldGroupE _ = Nothing++qqFieldGroupListE :: [C.FieldGroup] -> Maybe (Q Exp)+qqFieldGroupListE [] = Just [|[]|]+qqFieldGroupListE (C.AntiSdecls v _ : fields) =+ Just [|$(antiVarE v) ++ $(dataToExpQ qqExp fields)|]+qqFieldGroupListE (field : fields) =+ Just [|$(dataToExpQ qqExp field) : $(dataToExpQ qqExp fields)|]++qqCEnumE :: C.CEnum -> Maybe (Q Exp)+qqCEnumE (C.AntiEnum v _) = Just $ antiVarE v+qqCEnumE _ = Nothing++qqCEnumListE :: [C.CEnum] -> Maybe (Q Exp)+qqCEnumListE [] = Just [|[]|]+qqCEnumListE (C.AntiEnums v _ : fields) =+ Just [|$(antiVarE v) ++ $(dataToExpQ qqExp fields)|]+qqCEnumListE (field : fields) =+ Just [|$(dataToExpQ qqExp field) : $(dataToExpQ qqExp fields)|]++qqParamE :: C.Param -> Maybe (Q Exp)+qqParamE (C.AntiParam v _) = Just $ antiVarE v+qqParamE _ = Nothing++qqParamListE :: [C.Param] -> Maybe (Q Exp)+qqParamListE [] = Just [|[]|]+qqParamListE (C.AntiParams v _ : args) =+ Just [|$(antiVarE v) ++ $(dataToExpQ qqExp args)|]+qqParamListE (arg : args) =+ Just [|$(dataToExpQ qqExp arg) : $(dataToExpQ qqExp args)|]++qqDefinitionE :: C.Definition -> Maybe (Q Exp)+qqDefinitionE (C.AntiFunc v loc) =+ Just [|C.FuncDef $(antiVarE v) $(qqLocE loc)|]+qqDefinitionE (C.AntiEsc v loc) =+ Just [|C.EscDef $(antiVarE v) $(qqLocE loc)|]+qqDefinitionE (C.AntiEdecl v _) =+ Just $ antiVarE v+qqDefinitionE _ = Nothing++qqDefinitionListE :: [C.Definition] -> Maybe (Q Exp)+qqDefinitionListE [] = Just [|[]|]+qqDefinitionListE (C.AntiEdecls v _ : defs) =+ Just [|$(antiVarE v) ++ $(dataToExpQ qqExp defs)|]+qqDefinitionListE (def : defs) =+ Just [|$(dataToExpQ qqExp def) : $(dataToExpQ qqExp defs)|]++qqConstE :: C.Const -> Maybe (Q Exp)+qqConstE = go+ where+ go (C.AntiInt v loc) =+ Just [|C.IntConst $(intConst (antiVarE v)) C.Signed+ (fromIntegral $(antiVarE v))+ $(qqLocE loc)|]++ go (C.AntiUInt v loc) =+ Just [|C.IntConst ($(intConst (antiVarE v)) ++ "U") C.Unsigned+ (fromIntegral $(antiVarE v))+ $(qqLocE loc)|]++ go (C.AntiLInt v loc) =+ Just [|C.LongIntConst ($(intConst (antiVarE v)) ++ "L") C.Signed+ (fromIntegral $(antiVarE v))+ $(qqLocE loc)|]++ go (C.AntiULInt v loc) =+ Just [|C.LongIntConst ($(intConst (antiVarE v)) ++ "UL") C.Unsigned+ (fromIntegral $(antiVarE v))+ $(qqLocE loc)|]++ go (C.AntiFloat v loc) =+ Just [|C.FloatConst ($(floatConst (antiVarE v)) ++ "F")+ (fromRational $(antiVarE v))+ $(qqLocE loc)|]++ go (C.AntiDouble v loc) =+ Just [|C.DoubleConst ($(floatConst (antiVarE v)))+ (fromRational $(antiVarE v))+ $(qqLocE loc)|]++ go (C.AntiLongDouble v loc) =+ Just [|C.LongDoubleConst ($(floatConst (antiVarE v)) ++ "L")+ (fromRational $(antiVarE v))+ $(qqLocE loc)|]++ go (C.AntiChar v loc) =+ Just [|C.CharConst (show $(antiVarE v)) $(antiVarE v) $(qqLocE loc)|]++ go (C.AntiString v loc) =+ Just [|C.StringConst [show $(antiVarE v)] $(antiVarE v) $(qqLocE loc)|]++ go _ = Nothing++ intConst :: ExpQ -> ExpQ+ intConst e = [|show $(e)|]++ floatConst :: ExpQ -> ExpQ+ floatConst e = [|show (fromRational $(e) :: Double)|]++qqExpE :: C.Exp -> Maybe (Q Exp)+qqExpE (C.AntiExp v _) = Just [|toExp $(antiVarE v) :: C.Exp|]+qqExpE _ = Nothing++qqExpListE :: [C.Exp] -> Maybe (Q Exp)+qqExpListE [] = Just [|[]|]+qqExpListE (C.AntiArgs v _ : exps) =+ Just [|map toExp $(antiVarE v) ++ $(dataToExpQ qqExp exps)|]+qqExpListE (exp : exps) =+ Just [|$(dataToExpQ qqExp exp) : $(dataToExpQ qqExp exps)|]++qqStmE :: C.Stm -> Maybe (Q Exp)+qqStmE (C.AntiStm v _) = Just $ antiVarE v+qqStmE _ = Nothing++qqStmListE :: [C.Stm] -> Maybe (Q Exp)+qqStmListE [] = Just [|[]|]+qqStmListE (C.AntiStms v _ : stms) =+ Just [|$(antiVarE v) ++ $(dataToExpQ qqExp stms)|]+qqStmListE (stm : stms) =+ Just [|$(dataToExpQ qqExp stm) : $(dataToExpQ qqExp stms)|]++qqBlockItemE :: C.BlockItem -> Maybe (Q Exp)+qqBlockItemE (C.AntiBlockItem v _) = Just $ antiVarE v+qqBlockItemE _ = Nothing++qqBlockItemListE :: [C.BlockItem] -> Maybe (Q Exp)+qqBlockItemListE [] = Just [|[]|]+qqBlockItemListE (C.BlockDecl (C.AntiDecls v _) : items) =+ Just [|map C.BlockDecl $(antiVarE v) ++ $(dataToExpQ qqExp items)|]+qqBlockItemListE (C.BlockStm (C.AntiStms v _) : items) =+ Just [|map C.BlockStm $(antiVarE v) ++ $(dataToExpQ qqExp items)|]+qqBlockItemListE (C.AntiBlockItems v _ : items) =+ Just [|$(antiVarE v) ++ $(dataToExpQ qqExp items)|]+qqBlockItemListE (stm : stms) =+ Just [|$(dataToExpQ qqExp stm) : $(dataToExpQ qqExp stms)|]++qqExp :: Typeable a => a -> Maybe (Q Exp)+qqExp = const Nothing `extQ` qqStringE+ `extQ` qqIdE+ `extQ` qqDeclSpecE+ `extQ` qqDeclE+ `extQ` qqTypeE+ `extQ` qqInitGroupE+ `extQ` qqInitGroupListE+ `extQ` qqFieldGroupE+ `extQ` qqFieldGroupListE+ `extQ` qqCEnumE+ `extQ` qqCEnumListE+ `extQ` qqParamE+ `extQ` qqParamListE+ `extQ` qqDefinitionE+ `extQ` qqDefinitionListE+ `extQ` qqConstE+ `extQ` qqExpE+ `extQ` qqExpListE+ `extQ` qqStmE+ `extQ` qqStmListE+ `extQ` qqBlockItemE+ `extQ` qqBlockItemListE++antiVarP :: String -> PatQ+antiVarP = either fail return . parsePat++qqStringP :: String -> Maybe (Q Pat)+qqStringP s = Just $ litP $ stringL s++qqLocP :: Data.Loc.Loc -> Maybe (Q Pat)+qqLocP _ = Just $ wildP++qqIdP :: C.Id -> Maybe (Q Pat)+qqIdP (C.AntiId v _) = Just $ conP (mkName "C.Id") [antiVarP v, wildP]+qqIdP _ = Nothing++qqDeclSpecP :: C.DeclSpec -> Maybe (Q Pat)+qqDeclSpecP (C.AntiDeclSpec v _) = Just $ antiVarP v+qqDeclSpecP (C.AntiTypeDeclSpec {}) =+ error "Illegal antiquoted type in pattern"+qqDeclSpecP _ = Nothing++qqDeclP :: C.Decl -> Maybe (Q Pat)+qqDeclP (C.AntiTypeDecl {}) =+ error "Illegal antiquoted type in pattern"+qqDeclP _ = Nothing++qqTypeP :: C.Type -> Maybe (Q Pat)+qqTypeP (C.AntiType v _) = Just $ antiVarP v+qqTypeP _ = Nothing++qqInitGroupP :: C.InitGroup -> Maybe (Q Pat)+qqInitGroupP (C.AntiDecl v _) = Just $ antiVarP v+qqInitGroupP _ = Nothing++qqInitGroupListP :: [C.InitGroup] -> Maybe (Q Pat)+qqInitGroupListP [] = Just $ listP []+qqInitGroupListP [C.AntiDecls v _] = Just $ antiVarP v+qqInitGroupListP (C.AntiDecls {} : _ : _) =+ error "Antiquoted list of initialization groups must be last item in quoted list"+qqInitGroupListP (ini : inis) =+ Just $ conP (mkName ":") [dataToPatQ qqPat ini, dataToPatQ qqPat inis]++qqFieldGroupP :: C.FieldGroup -> Maybe (Q Pat)+qqFieldGroupP (C.AntiSdecl v _) = Just $ antiVarP v+qqFieldGroupP _ = Nothing++qqFieldGroupListP :: [C.FieldGroup] -> Maybe (Q Pat)+qqFieldGroupListP [] = Just $ listP []+qqFieldGroupListP [C.AntiSdecls v _] = Just $ antiVarP v+qqFieldGroupListP (C.AntiSdecls {} : _ : _) =+ error "Antiquoted list of struct/union fields must be last item in quoted list"+qqFieldGroupListP (ini : inis) =+ Just $ conP (mkName ":") [dataToPatQ qqPat ini, dataToPatQ qqPat inis]++qqCEnumP :: C.CEnum -> Maybe (Q Pat)+qqCEnumP (C.AntiEnum v _) = Just $ antiVarP v+qqCEnumP _ = Nothing++qqCEnumListP :: [C.CEnum] -> Maybe (Q Pat)+qqCEnumListP [] = Just $ listP []+qqCEnumListP [C.AntiEnums v _] = Just $ antiVarP v+qqCEnumListP (C.AntiEnums {} : _ : _) =+ error "Antiquoted list of enumerations must be last item in quoted list"+qqCEnumListP (ini : inis) =+ Just $ conP (mkName ":") [dataToPatQ qqPat ini, dataToPatQ qqPat inis]++qqParamP :: C.Param -> Maybe (Q Pat)+qqParamP (C.AntiParam v _) = Just $ antiVarP v+qqParamP _ = Nothing++qqParamListP :: [C.Param] -> Maybe (Q Pat)+qqParamListP [] = Just $ listP []+qqParamListP [C.AntiParams v _] = Just $ antiVarP v+qqParamListP (C.AntiParams {} : _ : _) =+ error "Antiquoted list of parameters must be last item in quoted list"+qqParamListP (arg : args) =+ Just $ conP (mkName ":") [dataToPatQ qqPat arg, dataToPatQ qqPat args]++qqDefinitionP :: C.Definition -> Maybe (Q Pat)+qqDefinitionP (C.AntiFunc v _) = Just $ conP (mkName "C.FuncDef") [antiVarP v, wildP]+qqDefinitionP (C.AntiEsc v _) = Just $ conP (mkName "C.EscDef") [antiVarP v, wildP]+qqDefinitionP (C.AntiEdecl v _) = Just $ antiVarP v+qqDefinitionP _ = Nothing++qqDefinitionListP :: [C.Definition] -> Maybe (Q Pat)+qqDefinitionListP [] = Just $ listP []+qqDefinitionListP [C.AntiEdecls v _] = Just $ antiVarP v+qqDefinitionListP (C.AntiEdecls {} : _ : _) =+ error "Antiquoted list of definitions must be last item in quoted list"+qqDefinitionListP (arg : args) =+ Just $ conP (mkName ":") [dataToPatQ qqPat arg, dataToPatQ qqPat args]++qqConstP :: C.Const -> Maybe (Q Pat)+qqConstP = go+ where+ go (C.AntiInt v _) =+ Just $ (con "C.IntConst") [wildP, signed, antiVarP v, wildP]+ go (C.AntiUInt v _) =+ Just $ (con "C.IntConst") [wildP, unsigned, antiVarP v, wildP]+ go (C.AntiLInt v _) =+ Just $ (con "C.LongIntConst") [wildP, signed, antiVarP v, wildP]+ go (C.AntiULInt v _) =+ Just $ (con "C.LongIntConst") [wildP, unsigned, antiVarP v, wildP]+ go (C.AntiFloat v _) =+ Just $ (con "C.FloatConst") [wildP, antiVarP v, wildP]+ go (C.AntiDouble v _) =+ Just $ (con "C.DoubleConst") [wildP, antiVarP v, wildP]+ go (C.AntiLongDouble v _) =+ Just $ (con "C.LongDoubleConst") [wildP, antiVarP v, wildP]+ go (C.AntiChar v _) =+ Just $ (con "C.CharConst") [wildP, antiVarP v, wildP]+ go (C.AntiString v _) =+ Just $ (con "C.StringConst") [wildP, antiVarP v, wildP]+ go _ =+ Nothing++ con n = conP (mkName n)++ signed = conP (mkName "C.Signed") []+ unsigned = conP (mkName "C.Unsigned") []++qqExpP :: C.Exp -> Maybe (Q Pat)+qqExpP (C.AntiExp v _) = Just $ antiVarP v+qqExpP _ = Nothing++qqExpListP :: [C.Exp] -> Maybe (Q Pat)+qqExpListP [] = Just $ listP []+qqExpListP [C.AntiArgs v _] = Just $ antiVarP v+qqExpListP (C.AntiArgs {} : _ : _) =+ error "Antiquoted list of arguments must be last item in quoted list"+qqExpListP (arg : args) =+ Just $ conP (mkName ":") [dataToPatQ qqPat arg, dataToPatQ qqPat args]++qqStmP :: C.Stm -> Maybe (Q Pat)+qqStmP (C.AntiStm v _) = Just $ antiVarP v+qqStmP _ = Nothing++qqStmListP :: [C.Stm] -> Maybe (Q Pat)+qqStmListP [] = Just $ listP []+qqStmListP [C.AntiStms v _] = Just $ antiVarP v+qqStmListP (C.AntiStms {} : _ : _) =+ error "Antiquoted list of statements must be last item in quoted list"+qqStmListP (arg : args) =+ Just $ conP (mkName ":") [dataToPatQ qqPat arg, dataToPatQ qqPat args]++qqBlockItemP :: C.BlockItem -> Maybe (Q Pat)+qqBlockItemP (C.AntiBlockItem v _) = Just $ antiVarP v+qqBlockItemP _ = Nothing++qqBlockItemListP :: [C.BlockItem] -> Maybe (Q Pat)+qqBlockItemListP [] = Just $ listP []+qqBlockItemListP (C.BlockDecl (C.AntiDecls {}) : _) =+ error "Antiquoted list of declarations cannot appear in block"+qqBlockItemListP (C.BlockStm (C.AntiStms {}) : _) =+ error "Antiquoted list of statements cannot appear in block"+qqBlockItemListP [C.AntiBlockItems v _] = Just $ antiVarP v+qqBlockItemListP (C.AntiBlockItems {} : _ : _) =+ error "Antiquoted list of block items must be last item in quoted list"+qqBlockItemListP (arg : args) =+ Just $ conP (mkName ":") [dataToPatQ qqPat arg, dataToPatQ qqPat args]++qqPat :: Typeable a => a -> Maybe (Q Pat)+qqPat = const Nothing `extQ` qqStringP+ `extQ` qqLocP+ `extQ` qqIdP+ `extQ` qqDeclSpecP+ `extQ` qqDeclP+ `extQ` qqTypeP+ `extQ` qqInitGroupP+ `extQ` qqInitGroupListP+ `extQ` qqFieldGroupP+ `extQ` qqCEnumP+ `extQ` qqCEnumListP+ `extQ` qqParamP+ `extQ` qqParamListP+ `extQ` qqDefinitionP+ `extQ` qqDefinitionListP+ `extQ` qqConstP+ `extQ` qqExpP+ `extQ` qqExpListP+ `extQ` qqStmP+ `extQ` qqStmListP+ `extQ` qqBlockItemP+ `extQ` qqBlockItemListP++parse :: [C.Extensions]+ -> [String]+ -> P.P a+ -> String+ -> Q a+parse exts typenames p s = do+ loc <- location+ case P.parse exts typenames P.ParseQuasiQuote p (B.pack s) (locToPos loc) of+ Left err -> fail (show err)+ Right x -> return x+ where+ locToPos :: Language.Haskell.TH.Loc -> Pos+ locToPos loc = Pos ((intern . loc_filename) loc)+ ((fst . loc_start) loc)+ ((snd . loc_start) loc)+ 0++quasiquote :: Data a+ => [C.Extensions]+ -> [String]+ -> P.P a+ -> QuasiQuoter+quasiquote exts typenames p =+ QuasiQuoter { quoteExp = parse exts typenames p >=> dataToExpQ qqExp+ , quotePat = parse exts typenames p >=> dataToPatQ qqPat+ }++dataToQa :: forall a k q. Data a+ => (String -> k)+ -> (Lit -> Q q)+ -> (k -> [Q q] -> Q q)+ -> (forall a . Data a => a -> Maybe (Q q))+ -> a+ -> Q q+dataToQa mkCon mkLit appCon antiQ t =+ case antiQ t of+ Just x -> x+ Nothing ->+ case constrRep constr of+ AlgConstr _ -> appCon con conArgs+ IntConstr n -> mkLit $ integerL n+ FloatConstr n -> mkLit $ rationalL (toRational n)+#if MIN_VERSION_template_haskell(2,4,0)+ CharConstr c -> mkLit $ charL c+#else /* !MIN_VERSION_template_haskell(2,4,0) */+ StringConstr [c] -> mkLit $ charL c+ StringConstr s -> mkLit $ stringL s+#endif /* !MIN_VERSION_template_haskell(2,4,0) */+ where+ constr :: Constr+ constr = toConstr t++ con :: k+ con = mkCon (constrName constr)+ where+ constrName :: Constr -> String+ constrName k =+ case showConstr k of+ "(:)" -> ":"+ name | name `elem` unqualifiedConstructors -> name+ | otherwise -> "Language.C.Syntax." ++ name++ conArgs :: [Q q]+ conArgs = gmapQ (dataToQa mkCon mkLit appCon antiQ) t++ unqualifiedConstructors :: [String]+ unqualifiedConstructors = ["[]", "(,)", "(,,)", ":%",+ "True", "False",+ "Just", "Nothing",+ "Left", "Right",+ "Symbol",+ "Loc", "NoLoc", "Pos", "SrcLoc"]++dataToExpQ :: Data a+ => (forall a . Data a => a -> Maybe (Q Exp))+ -> a+ -> Q Exp+dataToExpQ = dataToQa mkCon litE (foldl appE)+ where+ mkCon :: String -> Q Exp+ mkCon ":%" = (varE . mkName) "%"+ mkCon s = (conE . mkName) s++dataToPatQ :: Data a+ => (forall a . Data a => a -> Maybe (Q Pat))+ -> a+ -> Q Pat+dataToPatQ = dataToQa mkName litP conP
+ Language/C/Quote/C.hs view
@@ -0,0 +1,79 @@+-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Quote.C+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Quote.C (+ module Data.Loc,+ module Data.Ratio,+ module Data.Symbol,+ ToExp(..),+ cexp,+ cedecl,+ cdecl,+ csdecl,+ cenum,+ cty,+ cparam,+ cinit,+ cstm,+ cunit,+ cfun+ ) where++import Data.Loc+import Data.Ratio ((%))+import Data.Symbol++import qualified Language.C.Parser as P+import qualified Language.C.Syntax as C+import Language.C.Quote.Base++exts :: [C.Extensions]+exts = []++typenames :: [String]+typenames = []++cdecl = quasiquote exts typenames P.parseDecl+cedecl = quasiquote exts typenames P.parseEdecl+cenum = quasiquote exts typenames P.parseEnum+cexp = quasiquote exts typenames P.parseExp+cfun = quasiquote exts typenames P.parseFunc+cinit = quasiquote exts typenames P.parseInit+cparam = quasiquote exts typenames P.parseParam+csdecl = quasiquote exts typenames P.parseStructDecl+cstm = quasiquote exts typenames P.parseStm+cty = quasiquote exts typenames P.parseType+cunit = quasiquote exts typenames P.parseUnit
+ Language/C/Quote/CUDA.hs view
@@ -0,0 +1,88 @@+-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Quote.CUDA+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Quote.CUDA (+ module Data.Loc,+ module Data.Ratio,+ module Data.Symbol,+ ToExp(..),+ cexp,+ cedecl,+ cdecl,+ csdecl,+ cenum,+ cty,+ cparam,+ cinit,+ cstm,+ cunit,+ cfun+ ) where++import Data.Loc+import Data.Ratio ((%))+import Data.Symbol++import qualified Language.C.Parser as P+import qualified Language.C.Syntax as C+import Language.C.Quote.Base++exts :: [C.Extensions]+exts = [C.CUDA]++typenames :: [String]+typenames =+ [ "char1", "uchar1", "char2", "uchar2", "char3", "uchar3", "char4", "uchar4"+ , "short1", "ushort1", "short2", "ushort2", "short3", "ushort3"+ , "short4", "ushort4"+ , "int1", "uint1", "int2", "uint2", "int3", "uint3", "int4", "uint4"+ , "long1", "ulong1", "long2", "ulong2", "long3", "ulong3", "long4", "ulong4"+ , "longlong1", "longlong2"+ , "float1", "float2", "float3"," float4", "double1", "double2"+ , "dim3"+ ]++cdecl = quasiquote exts typenames P.parseDecl+cedecl = quasiquote exts typenames P.parseEdecl+cenum = quasiquote exts typenames P.parseEnum+cexp = quasiquote exts typenames P.parseExp+cfun = quasiquote exts typenames P.parseFunc+cinit = quasiquote exts typenames P.parseInit+cparam = quasiquote exts typenames P.parseParam+csdecl = quasiquote exts typenames P.parseStructDecl+cstm = quasiquote exts typenames P.parseStm+cty = quasiquote exts typenames P.parseType+cunit = quasiquote exts typenames P.parseUnit
+ Language/C/Quote/GCC.hs view
@@ -0,0 +1,79 @@+-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Quote.C+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Quote.GCC (+ module Data.Loc,+ module Data.Ratio,+ module Data.Symbol,+ ToExp(..),+ cexp,+ cedecl,+ cdecl,+ csdecl,+ cenum,+ cty,+ cparam,+ cinit,+ cstm,+ cunit,+ cfun+ ) where++import Data.Loc+import Data.Ratio ((%))+import Data.Symbol++import qualified Language.C.Parser as P+import qualified Language.C.Syntax as C+import Language.C.Quote.Base++exts :: [C.Extensions]+exts = [C.Gcc]++typenames :: [String]+typenames = []++cdecl = quasiquote exts typenames P.parseDecl+cedecl = quasiquote exts typenames P.parseEdecl+cenum = quasiquote exts typenames P.parseEnum+cexp = quasiquote exts typenames P.parseExp+cfun = quasiquote exts typenames P.parseFunc+cinit = quasiquote exts typenames P.parseInit+cparam = quasiquote exts typenames P.parseParam+csdecl = quasiquote exts typenames P.parseStructDecl+cstm = quasiquote exts typenames P.parseStm+cty = quasiquote exts typenames P.parseType+cunit = quasiquote exts typenames P.parseUnit
+ Language/C/Smart.hs view
@@ -0,0 +1,110 @@+-- Copyright (c) 2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Smart+-- Copyright : (c) Harvard University2008+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++{-# LANGUAGE QuasiQuotes #-}++module Language.C.Smart where++import Language.C.Quote.C+import qualified Language.C.Syntax as C+import qualified Language.C.Syntax++instance Enum C.Exp where+ toEnum n = [$cexp|$int:n|]++ fromEnum [$cexp|$int:n|] = fromIntegral n+ fromEnum [$cexp|$uint:n|] = fromIntegral n+ fromEnum [$cexp|$lint:n|] = fromIntegral n+ fromEnum [$cexp|$ulint:n|] = fromIntegral n+ fromEnum _ = error "fromEnum: non-integer constant C expressions"++instance Num C.Exp where+ e1 + e2 = [$cexp|$exp:e1 + $exp:e2|]+ e1 * e2 = [$cexp|$exp:e1 * $exp:e2|]+ e1 - e2 = [$cexp|$exp:e1 - $exp:e2|]+ negate e = [$cexp|-$exp:e|]+ abs e = [$cexp|abs($exp:e)|]+ signum e = [$cexp|$exp:e > 0 ? 1 : ($exp:e < 0 ? -1 : 0)|]+ fromInteger n = [$cexp|$int:n|]++instance Real C.Exp where+ toRational [$cexp|$float:n|] = n+ toRational [$cexp|$double:n|] = n+ toRational [$cexp|$ldouble:n|] = n+ toRational _ = error "fromEnum: non-rational constant C expressions"++instance Integral C.Exp where+ e1 `quotRem` e2 = ([$cexp|$exp:e1 / $exp:e2|], [$cexp|$exp:e1 % $exp:e2|])++ toInteger [$cexp|$int:n|] = n+ toInteger [$cexp|$uint:n|] = n+ toInteger [$cexp|$lint:n|] = n+ toInteger [$cexp|$ulint:n|] = n+ toInteger _ = error "fromInteger: non-integer constant C expressions"++instance Fractional C.Exp where+ e1 / e2 = [$cexp|$exp:e1 / $exp:e2|]+ recip e = [$cexp|1 / $exp:e|]++ fromRational n = [$cexp|$double:n|]++instance Floating C.Exp where+ pi = [$cexp|3.141592653589793238|]+ exp e = [$cexp|exp($exp:e)|]+ sqrt e = [$cexp|sqrt($exp:e)|]+ log e = [$cexp|log($exp:e)|]+ e1 ** e2 = [$cexp|pow($exp:e1, $exp:e2)|]+ logBase e1 e2 = [$cexp|log($exp:e2)/log($exp:e1)|]+ sin e = [$cexp|sin($exp:e)|]+ tan e = [$cexp|tan($exp:e)|]+ cos e = [$cexp|cos($exp:e)|]+ asin e = [$cexp|asin($exp:e)|]+ atan e = [$cexp|atan($exp:e)|]+ acos e = [$cexp|acos($exp:e)|]+ sinh e = [$cexp|sinh($exp:e)|]+ tanh e = [$cexp|tanh($exp:e)|]+ cosh e = [$cexp|cosh($exp:e)|]+ asinh e = [$cexp|asinh($exp:e)|]+ atanh e = [$cexp|atanh($exp:e)|]+ acosh e = [$cexp|acosh($exp:e)|]++infix 4 ===+(===) :: C.Exp -> C.Exp -> C.Stm+e1 === e2 = [$cstm|$exp:e1 = $exp:e2;|]++infix 4 +=+(+=) :: C.Exp -> C.Exp -> C.Stm+e1 += e2 = [$cstm|$exp:e1 += $exp:e2;|]
+ Language/C/Syntax.hs view
@@ -0,0 +1,557 @@+-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Syntax+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleInstances #-}++module Language.C.Syntax where++import Data.Generics++import Data.Loc++data Extensions = Gcc+ | CUDA+ deriving (Eq, Ord, Enum, Show)++data Id = Id String !SrcLoc+ | AntiId String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Storage = Tauto !SrcLoc+ | Tregister !SrcLoc+ | Tstatic !SrcLoc+ | Textern !SrcLoc+ | TexternL String !SrcLoc+ | Ttypedef !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data TypeQual = Tconst !SrcLoc+ | Tvolatile !SrcLoc+ | Tinline !SrcLoc++ -- C99+ | Trestrict !SrcLoc++ -- CUDA+ | Tdevice !SrcLoc+ | Tglobal !SrcLoc+ | Thost !SrcLoc+ | Tconstant !SrcLoc+ | Tshared !SrcLoc+ | Tnoinline !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Sign = Tsigned !SrcLoc+ | Tunsigned !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data TypeSpec = Tvoid !SrcLoc+ | Tchar (Maybe Sign) !SrcLoc+ | Tshort (Maybe Sign) !SrcLoc+ | Tint (Maybe Sign) !SrcLoc+ | Tlong (Maybe Sign) !SrcLoc+ | Tlong_long (Maybe Sign) !SrcLoc+ | Tfloat !SrcLoc+ | Tdouble !SrcLoc+ | Tlong_double !SrcLoc+ | Tstruct (Maybe Id) (Maybe [FieldGroup]) [Attr] !SrcLoc+ | Tunion (Maybe Id) (Maybe [FieldGroup]) [Attr] !SrcLoc+ | Tenum (Maybe Id) [CEnum] [Attr] !SrcLoc+ | Tnamed Id !SrcLoc+ | TtypeofExp Exp !SrcLoc+ | TtypeofType Type !SrcLoc+ | Tva_list !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data DeclSpec = DeclSpec [Storage] [TypeQual] TypeSpec !SrcLoc+ | AntiDeclSpec String !SrcLoc+ | AntiTypeDeclSpec [Storage] [TypeQual] String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++-- | There are two types of declarators in C, regular declarators and abstract+-- declarators. The former is for declaring variables, function parameters,+-- typedefs, etc. and the latter for abstract types---@typedef int+-- ({*}foo)(void)@ vs. @\tt int ({*})(void)@. The difference between the two is+-- just whether or not an identifier is attached to the declarator. We therefore+-- only define one 'Decl' type and use it for both cases.++data ArraySize = ArraySize Bool Exp !SrcLoc+ | VariableArraySize !SrcLoc+ | NoArraySize !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Decl = DeclRoot !SrcLoc+ | Ptr [TypeQual] Decl !SrcLoc+ | Array [TypeQual] ArraySize Decl !SrcLoc+ | Proto Decl Params !SrcLoc+ | OldProto Decl [Id] !SrcLoc+ | AntiTypeDecl String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Type = Type DeclSpec Decl !SrcLoc+ | AntiType String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Designator = IndexDesignator Exp !SrcLoc+ | MemberDesignator Id !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Designation = Designation [Designator] !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Initializer = ExpInitializer Exp !SrcLoc+ | CompoundInitializer [(Maybe Designation, Initializer)] !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++type AsmLabel = String++data Init = Init Id Decl (Maybe AsmLabel) (Maybe Initializer) [Attr] !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Typedef = Typedef Id Decl [Attr] !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data InitGroup = InitGroup DeclSpec [Attr] [Init] !SrcLoc+ | TypedefGroup DeclSpec [Attr] [Typedef] !SrcLoc+ | AntiDecl String !SrcLoc+ | AntiDecls String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Field = Field (Maybe Id) (Maybe Decl) (Maybe Exp) !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data FieldGroup = FieldGroup DeclSpec [Field] !SrcLoc+ | AntiSdecl String !SrcLoc+ | AntiSdecls String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data CEnum = CEnum Id (Maybe Exp) !SrcLoc+ | AntiEnum String !SrcLoc+ | AntiEnums String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Attr = Attr Id [Exp] !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Param = Param (Maybe Id) DeclSpec Decl !SrcLoc+ | AntiParam String !SrcLoc+ | AntiParams String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Params = Params [Param] Bool !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Func = Func DeclSpec Id Decl Params [BlockItem] !SrcLoc+ | OldFunc DeclSpec Id Decl [Id] (Maybe [InitGroup]) [BlockItem] !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Definition = FuncDef Func !SrcLoc+ | DecDef InitGroup !SrcLoc+ | EscDef String !SrcLoc+ | AntiFunc String !SrcLoc+ | AntiEsc String !SrcLoc+ | AntiEdecl String !SrcLoc+ | AntiEdecls String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data Stm = Label Id Stm !SrcLoc+ | Case Exp Stm !SrcLoc+ | Default Stm !SrcLoc+ | Exp (Maybe Exp) !SrcLoc+ | Block [BlockItem] !SrcLoc+ | If Exp Stm (Maybe Stm) !SrcLoc+ | Switch Exp Stm !SrcLoc+ | While Exp Stm !SrcLoc+ | DoWhile Stm Exp !SrcLoc+ | For (Either InitGroup (Maybe Exp)) (Maybe Exp) (Maybe Exp) Stm+ !SrcLoc+ | Goto Id !SrcLoc+ | Continue !SrcLoc+ | Break !SrcLoc+ | Return (Maybe Exp) !SrcLoc+ | Asm Bool [Attr] [String] [(String, Exp)] [(String, Exp)] [String] !SrcLoc+ | AntiStm String !SrcLoc+ | AntiStms String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data BlockItem = BlockDecl InitGroup+ | BlockStm Stm+ | AntiBlockItem String !SrcLoc+ | AntiBlockItems String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++funcProto :: Func -> InitGroup+funcProto f@(Func decl_spec id decl params _ _) =+ InitGroup decl_spec [] [Init id (Proto decl params loc) Nothing Nothing [] loc] loc+ where+ loc = locOf f++funcProto f@(OldFunc decl_spec id decl params _ _ _) =+ InitGroup decl_spec [] [Init id (OldProto decl params loc) Nothing Nothing [] loc]+ loc+ where+ loc = locOf f++isPtr :: Type -> Bool+isPtr (Type _ decl _) = go decl+ where+ go (DeclRoot _) = False+ go (Ptr _ _ _) = True+ go (Array _ _ _ _) = True+ go (Proto _ _ _) = False+ go (OldProto _ _ _) = False+ go (AntiTypeDecl _ _) = error "isPtr: encountered antiquoted type declaration"+isPtr (AntiType _ _) = error "isPtr: encountered antiquoted type"++data Signed = Signed+ | Unsigned+ deriving (Eq, Ord, Data, Typeable)++data Const = IntConst String Signed Integer !SrcLoc+ | LongIntConst String Signed Integer !SrcLoc+ | LongLongIntConst String Signed Integer !SrcLoc+ | FloatConst String Rational !SrcLoc+ | DoubleConst String Rational !SrcLoc+ | LongDoubleConst String Rational !SrcLoc+ | CharConst String Char !SrcLoc+ | StringConst [String] String !SrcLoc+ | AntiInt String !SrcLoc+ | AntiUInt String !SrcLoc+ | AntiLInt String !SrcLoc+ | AntiULInt String !SrcLoc+ | AntiFloat String !SrcLoc+ | AntiDouble String !SrcLoc+ | AntiLongDouble String !SrcLoc+ | AntiChar String !SrcLoc+ | AntiString String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data ExeConfig = ExeConfig+ { exeGridDim :: Exp+ , exeBlockDim :: Exp+ , exeSharedSize :: Maybe Exp+ , exeStream :: Maybe Exp+ , exeLoc :: !SrcLoc+ }+ deriving (Eq, Ord, Data, Typeable)++data Exp = Var Id !SrcLoc+ | Const Const !SrcLoc+ | BinOp BinOp Exp Exp !SrcLoc+ | Assign Exp AssignOp Exp !SrcLoc+ | PreInc Exp !SrcLoc+ | PostInc Exp !SrcLoc+ | PreDec Exp !SrcLoc+ | PostDec Exp !SrcLoc+ | UnOp UnOp Exp !SrcLoc+ | SizeofExp Exp !SrcLoc+ | SizeofType Type !SrcLoc+ | Cast Type Exp !SrcLoc+ | Cond Exp Exp Exp !SrcLoc+ | Member Exp Id !SrcLoc+ | PtrMember Exp Id !SrcLoc+ | Index Exp Exp !SrcLoc+ | FnCall Exp [Exp] !SrcLoc+ | CudaCall Exp ExeConfig [Exp] !SrcLoc+ | Seq Exp Exp !SrcLoc+ | CompoundLit Type [(Maybe Designation, Initializer)] !SrcLoc+ | StmExpr [BlockItem] !SrcLoc+ | BuiltinVaArg Exp Type !SrcLoc+ | AntiExp String !SrcLoc+ | AntiArgs String !SrcLoc+ deriving (Eq, Ord, Data, Typeable)++data BinOp = Add+ | Sub+ | Mul+ | Div+ | Mod+ | Eq+ | Ne+ | Lt+ | Gt+ | Le+ | Ge+ | Land+ | Lor+ | And+ | Or+ | Xor+ | Lsh+ | Rsh+ deriving (Eq, Ord, Data, Typeable)++data AssignOp = JustAssign+ | AddAssign+ | SubAssign+ | MulAssign+ | DivAssign+ | ModAssign+ | LshAssign+ | RshAssign+ | AndAssign+ | XorAssign+ | OrAssign+ deriving (Eq, Ord, Data, Typeable)++data UnOp = AddrOf+ | Deref+ | Positive+ | Negate+ | Not+ | Lnot+ deriving (Eq, Ord, Data, Typeable)++instance Located Id where+ getLoc (Id _ loc) = getLoc loc+ getLoc (AntiId _ loc) = getLoc loc++instance Located Storage where+ getLoc (Tauto loc) = getLoc loc+ getLoc (Tregister loc) = getLoc loc+ getLoc (Tstatic loc) = getLoc loc+ getLoc (Textern loc) = getLoc loc+ getLoc (TexternL _ loc) = getLoc loc+ getLoc (Ttypedef loc) = getLoc loc++instance Located TypeQual where+ getLoc (Tconst loc) = getLoc loc+ getLoc (Tvolatile loc) = getLoc loc+ getLoc (Tinline loc) = getLoc loc++ getLoc (Trestrict loc) = getLoc loc++ getLoc (Tdevice loc) = getLoc loc+ getLoc (Tglobal loc) = getLoc loc+ getLoc (Thost loc) = getLoc loc+ getLoc (Tconstant loc) = getLoc loc+ getLoc (Tshared loc) = getLoc loc+ getLoc (Tnoinline loc) = getLoc loc++instance Located Sign where+ getLoc (Tsigned loc) = getLoc loc+ getLoc (Tunsigned loc) = getLoc loc++instance Located TypeSpec where+ getLoc (Tvoid loc) = getLoc loc+ getLoc (Tchar _ loc) = getLoc loc+ getLoc (Tshort _ loc) = getLoc loc+ getLoc (Tint _ loc) = getLoc loc+ getLoc (Tlong _ loc) = getLoc loc+ getLoc (Tlong_long _ loc) = getLoc loc+ getLoc (Tfloat loc) = getLoc loc+ getLoc (Tdouble loc) = getLoc loc+ getLoc (Tlong_double loc) = getLoc loc+ getLoc (Tstruct _ _ _ loc) = getLoc loc+ getLoc (Tunion _ _ _ loc) = getLoc loc+ getLoc (Tenum _ _ _ loc) = getLoc loc+ getLoc (Tnamed _ loc) = getLoc loc+ getLoc (TtypeofExp _ loc) = getLoc loc+ getLoc (TtypeofType _ loc) = getLoc loc+ getLoc (Tva_list loc) = getLoc loc++instance Located DeclSpec where+ getLoc (DeclSpec _ _ _ loc) = getLoc loc+ getLoc (AntiDeclSpec _ loc) = getLoc loc+ getLoc (AntiTypeDeclSpec _ _ _ loc) = getLoc loc++instance Located ArraySize where+ getLoc (ArraySize _ _ loc) = getLoc loc+ getLoc (VariableArraySize loc) = getLoc loc+ getLoc (NoArraySize loc) = getLoc loc++instance Located Decl where+ getLoc (DeclRoot loc) = getLoc loc+ getLoc (Ptr _ _ loc) = getLoc loc+ getLoc (Array _ _ _ loc) = getLoc loc+ getLoc (Proto _ _ loc) = getLoc loc+ getLoc (OldProto _ _ loc) = getLoc loc+ getLoc (AntiTypeDecl _ loc) = getLoc loc++instance Located Type where+ getLoc (Type _ _ loc) = getLoc loc+ getLoc (AntiType _ loc) = getLoc loc++instance Located Designator where+ getLoc (IndexDesignator _ loc) = getLoc loc+ getLoc (MemberDesignator _ loc) = getLoc loc++instance Located Designation where+ getLoc (Designation _ loc) = getLoc loc++instance Located Initializer where+ getLoc (ExpInitializer _ loc) = getLoc loc+ getLoc (CompoundInitializer _ loc) = getLoc loc++instance Located Init where+ getLoc (Init _ _ _ _ _ loc) = getLoc loc++instance Located Typedef where+ getLoc (Typedef _ _ _ loc) = getLoc loc++instance Located InitGroup where+ getLoc (InitGroup _ _ _ loc) = getLoc loc+ getLoc (TypedefGroup _ _ _ loc) = getLoc loc+ getLoc (AntiDecl _ loc) = getLoc loc+ getLoc (AntiDecls _ loc) = getLoc loc++instance Located Field where+ getLoc (Field _ _ _ loc) = getLoc loc++instance Located FieldGroup where+ getLoc (FieldGroup _ _ loc) = getLoc loc+ getLoc (AntiSdecl _ loc) = getLoc loc+ getLoc (AntiSdecls _ loc) = getLoc loc++instance Located CEnum where+ getLoc (CEnum _ _ loc) = getLoc loc+ getLoc (AntiEnum _ loc) = getLoc loc+ getLoc (AntiEnums _ loc) = getLoc loc++instance Located Attr where+ getLoc (Attr _ _ loc) = getLoc loc++instance Located Param where+ getLoc (Param _ _ _ loc) = getLoc loc+ getLoc (AntiParam _ loc) = getLoc loc+ getLoc (AntiParams _ loc) = getLoc loc++instance Located Params where+ getLoc (Params _ _ loc) = getLoc loc++instance Located Func where+ getLoc (Func _ _ _ _ _ loc) = getLoc loc+ getLoc (OldFunc _ _ _ _ _ _ loc) = getLoc loc++instance Located Definition where+ getLoc (FuncDef _ loc) = getLoc loc+ getLoc (DecDef _ loc) = getLoc loc+ getLoc (EscDef _ loc) = getLoc loc+ getLoc (AntiFunc _ loc) = getLoc loc+ getLoc (AntiEsc _ loc) = getLoc loc+ getLoc (AntiEdecl _ loc) = getLoc loc+ getLoc (AntiEdecls _ loc) = getLoc loc++instance Located Stm where+ getLoc (Label _ _ loc) = getLoc loc+ getLoc (Case _ _ loc) = getLoc loc+ getLoc (Default _ loc) = getLoc loc+ getLoc (Exp _ loc) = getLoc loc+ getLoc (Block _ loc) = getLoc loc+ getLoc (If _ _ _ loc) = getLoc loc+ getLoc (Switch _ _ loc) = getLoc loc+ getLoc (While _ _ loc) = getLoc loc+ getLoc (DoWhile _ _ loc) = getLoc loc+ getLoc (For _ _ _ _ loc) = getLoc loc+ getLoc (Goto _ loc) = getLoc loc+ getLoc (Continue loc) = getLoc loc+ getLoc (Break loc) = getLoc loc+ getLoc (Return _ loc) = getLoc loc+ getLoc (Asm _ _ _ _ _ _ loc) = getLoc loc+ getLoc (AntiStm _ loc) = getLoc loc+ getLoc (AntiStms _ loc) = getLoc loc++instance Located BlockItem where+ getLoc (BlockDecl decl) = getLoc decl+ getLoc (BlockStm stm) = getLoc stm+ getLoc (AntiBlockItem _ loc) = getLoc loc+ getLoc (AntiBlockItems _ loc) = getLoc loc++instance Located Const where+ getLoc (IntConst _ _ _ loc) = getLoc loc+ getLoc (LongIntConst _ _ _ loc) = getLoc loc+ getLoc (LongLongIntConst _ _ _ loc) = getLoc loc+ getLoc (FloatConst _ _ loc) = getLoc loc+ getLoc (DoubleConst _ _ loc) = getLoc loc+ getLoc (LongDoubleConst _ _ loc) = getLoc loc+ getLoc (CharConst _ _ loc) = getLoc loc+ getLoc (StringConst _ _ loc) = getLoc loc+ getLoc (AntiInt _ loc) = getLoc loc+ getLoc (AntiUInt _ loc) = getLoc loc+ getLoc (AntiLInt _ loc) = getLoc loc+ getLoc (AntiULInt _ loc) = getLoc loc+ getLoc (AntiFloat _ loc) = getLoc loc+ getLoc (AntiDouble _ loc) = getLoc loc+ getLoc (AntiLongDouble _ loc) = getLoc loc+ getLoc (AntiChar _ loc) = getLoc loc+ getLoc (AntiString _ loc) = getLoc loc++instance Located ExeConfig where+ getLoc conf = getLoc (exeLoc conf)++instance Located Exp where+ getLoc (Var _ loc) = getLoc loc+ getLoc (Const _ loc) = getLoc loc+ getLoc (BinOp _ _ _ loc) = getLoc loc+ getLoc (Assign _ _ _ loc) = getLoc loc+ getLoc (PreInc _ loc) = getLoc loc+ getLoc (PostInc _ loc) = getLoc loc+ getLoc (PreDec _ loc) = getLoc loc+ getLoc (PostDec _ loc) = getLoc loc+ getLoc (UnOp _ _ loc) = getLoc loc+ getLoc (SizeofExp _ loc) = getLoc loc+ getLoc (SizeofType _ loc) = getLoc loc+ getLoc (Cast _ _ loc) = getLoc loc+ getLoc (Cond _ _ _ loc) = getLoc loc+ getLoc (Member _ _ loc) = getLoc loc+ getLoc (PtrMember _ _ loc) = getLoc loc+ getLoc (Index _ _ loc) = getLoc loc+ getLoc (FnCall _ _ loc) = getLoc loc+ getLoc (CudaCall _ _ _ loc) = getLoc loc+ getLoc (Seq _ _ loc) = getLoc loc+ getLoc (CompoundLit _ _ loc) = getLoc loc+ getLoc (StmExpr _ loc) = getLoc loc+ getLoc (BuiltinVaArg _ _ loc) = getLoc loc+ getLoc (AntiExp _ loc) = getLoc loc+ getLoc (AntiArgs _ loc) = getLoc loc++ctypedef :: Id -> Decl -> [Attr] -> Typedef+ctypedef id decl attrs =+ Typedef id decl attrs ((id <--> decl :: Loc) <--> attrs)++cdeclSpec :: [Storage] -> [TypeQual] -> TypeSpec -> DeclSpec+cdeclSpec storage quals spec =+ DeclSpec storage quals spec ((storage <--> quals :: Loc) <--> spec)++cinitGroup :: DeclSpec -> [Attr] -> [Init] -> InitGroup+cinitGroup dspec attrs inis =+ InitGroup dspec attrs inis ((dspec <--> attrs :: Loc) <--> inis)++ctypedefGroup :: DeclSpec -> [Attr] -> [Typedef] -> InitGroup+ctypedefGroup dspec attrs typedefs =+ TypedefGroup dspec attrs typedefs ((dspec <--> attrs :: Loc) <--> typedefs)
+ Setup.hs view
@@ -0,0 +1,14 @@+import Distribution.PackageDescription+import Distribution.Simple+import Distribution.Simple.LocalBuildInfo+import System.FilePath+import System.Process (system)++main = defaultMainWithHooks hooks+ where+ hooks = simpleUserHooks { runTests = runTests' }++runTests' :: Args -> Bool -> PackageDescription -> LocalBuildInfo -> IO ()+runTests' _ _ _ lbi = system unit_test >> return ()+ where+ unit_test = buildDir lbi </> "unit-test" </> "unit-test"
+ dist/build/Language/C/Parser/Lexer.hs view
@@ -0,0 +1,718 @@+{-# OPTIONS -fglasgow-exts -cpp #-}+{-# LINE 1 "Language/C/Parser/Lexer.x" #-}++{-# OPTIONS -w #-}+{-# LANGUAGE CPP #-}++-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Parser.Lexer+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Parser.Lexer (+ lexToken+ ) where++import Control.Monad (when)+import Control.Monad.Error+import Control.Monad.Exception+import Control.Monad.Identity+import Control.Monad.State+import Control.Monad.Trans+import qualified Data.ByteString.Char8 as B+import Data.Char (isAlphaNum,+ isDigit,+ isOctDigit,+ isHexDigit,+ isLower,+ isSpace,+ chr,+ toLower)+import Data.List (foldl', intersperse)+import Data.Loc+import qualified Data.Map as Map+import Data.Ratio ((%))+import qualified Data.Set as Set+import Data.Symbol+import Data.Maybe (fromMaybe)+import Text.PrettyPrint.Mainland++import qualified Language.C.Syntax as C+import Language.C.Parser.Monad+import Language.C.Parser.Tokens++#if __GLASGOW_HASKELL__ >= 603+#include "ghcconfig.h"+#elif defined(__GLASGOW_HASKELL__)+#include "config.h"+#endif+#if __GLASGOW_HASKELL__ >= 503+import Data.Array+import Data.Char (ord)+import Data.Array.Base (unsafeAt)+#else+import Array+import Char (ord)+#endif+#if __GLASGOW_HASKELL__ >= 503+import GHC.Exts+#else+import GlaExts+#endif+alex_base :: AlexAddr+alex_base = AlexA# "\xf8\xff\xff\xff\x6e\x00\x00\x00\xbd\x00\x00\x00\x08\x01\x00\x00\x53\x01\x00\x00\x9e\x01\x00\x00\xe9\x01\x00\x00\x34\x02\x00\x00\x7f\x02\x00\x00\xca\x02\x00\x00\x00\x00\x00\x00\xe4\x02\x00\x00\xa2\xff\xff\xff\xcd\xff\xff\xff\x00\x00\x00\x00\x94\xff\xff\xff\xcf\xff\xff\xff\x00\x00\x00\x00\xa1\xff\xff\xff\x9d\xff\xff\xff\x98\xff\xff\xff\xd4\xff\xff\xff\x00\x00\x00\x00\xab\xff\xff\xff\xa3\xff\xff\xff\x9e\xff\xff\xff\xd9\xff\xff\xff\x00\x00\x00\x00\xac\xff\xff\xff\xa9\xff\xff\xff\xa8\xff\xff\xff\xfe\xff\xff\xff\x00\x00\x00\x00\x10\x00\x00\x00\xe5\xff\xff\xff\xf7\xff\xff\xff\x09\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x0b\x00\x00\x00\x1f\x00\x00\x00\x16\x00\x00\x00\x1e\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x12\x00\x00\x00\x26\x00\x00\x00\x20\x00\x00\x00\x25\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x00\x00\x58\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\xe2\x02\x00\x00\x8a\x00\x00\x00\x8f\x00\x00\x00\x8b\x00\x00\x00\x93\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x00\x00\xe7\x02\x00\x00\x8d\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\xab\x00\x00\x00\xb7\x00\x00\x00\xe1\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\xb6\x00\x00\x00\xd1\x00\x00\x00\x09\x01\x00\x00\x00\x00\x00\x00\xe2\x00\x00\x00\xda\x00\x00\x00\xeb\x02\x00\x00\x00\x00\x00\x00\x0d\x01\x00\x00\x00\x00\x00\x00\xe3\x00\x00\x00\x00\x01\x00\x00\xf8\x00\x00\x00\xed\x02\x00\x00\x00\x00\x00\x00\x2b\x01\x00\x00\x00\x00\x00\x00\xf1\x00\x00\x00\xfb\x00\x00\x00\xee\x02\x00\x00\x00\x00\x00\x00\x54\x01\x00\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x55\x01\x00\x00\x00\x00\x00\x00\x2c\x01\x00\x00\x2d\x01\x00\x00\x26\x01\x00\x00\xf0\x02\x00\x00\x00\x00\x00\x00\x59\x01\x00\x00\x00\x00\x00\x00\x49\x01\x00\x00\x42\x01\x00\x00\x12\x03\x00\x00\x00\x00\x00\x00\x76\x01\x00\x00\x00\x00\x00\x00\x14\x03\x00\x00\x00\x00\x00\x00\x77\x01\x00\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x9f\x01\x00\x00\x00\x00\x00\x00\x73\x01\x00\x00\x78\x01\x00\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x7b\x01\x00\x00\x6b\x01\x00\x00\x7d\x01\x00\x00\x8c\x01\x00\x00\x15\x03\x00\x00\x00\x00\x00\x00\xc0\x01\x00\x00\xf1\x01\x00\x00\xf2\x01\x00\x00\xf4\x01\x00\x00\x19\x02\x00\x00\x47\x03\x00\x00\x49\x03\x00\x00\x51\x03\x00\x00\x52\x03\x00\x00\x5b\x03\x00\x00\x64\x03\x00\x00\x6c\x03\x00\x00\x76\x03\x00\x00\xa7\x03\x00\x00\xb1\x03\x00\x00\xac\x03\x00\x00\xb6\x03\x00\x00\x60\x03\x00\x00\xfe\x02\x00\x00\xfd\x02\x00\x00\x1a\x02\x00\x00\x1b\x02\x00\x00\x1c\x02\x00\x00\x1d\x02\x00\x00\x68\x03\x00\x00\x70\x03\x00\x00\x72\x03\x00\x00\xc9\x03\x00\x00\xe3\x03\x00\x00\xe8\x03\x00\x00\xf3\x03\x00\x00\x0d\x04\x00\x00\x27\x04\x00\x00\x41\x04\x00\x00\x1e\x02\x00\x00\x1f\x02\x00\x00\xcc\x03\x00\x00\x00\x00\x00\x00\x44\x02\x00\x00\x45\x02\x00\x00\x46\x02\x00\x00\x3a\x02\x00\x00\x2f\x04\x00\x00\x4b\x04\x00\x00\x96\x04\x00\x00\xe1\x04\x00\x00\x2c\x05\x00\x00\x77\x05\x00\x00\xc2\x05\x00\x00\x0d\x06\x00\x00\x58\x06\x00\x00\xa3\x06\x00\x00\xee\x06\x00\x00\x39\x07\x00\x00\x84\x07\x00\x00\xcf\x07\x00\x00\x1a\x08\x00\x00\x65\x08\x00\x00\x00\x00\x00\x00\xb0\x08\x00\x00\xba\x08\x00\x00\xd7\x08\x00\x00\xf8\x08\x00\x00\x34\x04\x00\x00\x17\x09\x00\x00\x35\x09\x00\x00\x5b\x09\x00\x00\x81\x09\x00\x00\xac\x09\x00\x00\xd2\x09\x00\x00\x02\x09\x00\x00\xf2\x09\x00\x00\x21\x09\x00\x00\x00\x00\x00\x00\x25\x02\x00\x00\xac\x08\x00\x00\x65\x02\x00\x00\x26\x02\x00\x00\x00\x00\x00\x00\x28\x02\x00\x00\xad\x08\x00\x00\x66\x02\x00\x00\x70\x02\x00\x00\x00\x00\x00\x00\xfc\x09\x00\x00\x71\x02\x00\x00\xaf\x08\x00\x00\x6a\x02\x00\x00\xba\x02\x00\x00\x42\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x03\x00\x00\x00\x00\x00\x00\x17\x02\x00\x00\x53\x03\x00\x00\x09\x02\x00\x00\x0a\x02\x00\x00\x00\x00\x00\x00\xd1\x03\x00\x00\x4e\x03\x00\x00\x0c\x02\x00\x00\x53\x02\x00\x00\xc8\x02\x00\x00\xcc\x02\x00\x00\x50\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++alex_table :: AlexAddr+alex_table = AlexA# "\x00\x00\xac\x00\xac\x00\xac\x00\xac\x00\xac\x00\x0d\x00\x0a\x00\x10\x00\x0e\x00\x13\x00\x14\x00\x15\x00\x1c\x00\x11\x00\x2e\x00\x0f\x00\x19\x00\x1a\x00\x16\x00\x18\x00\x1d\x00\x6b\x00\x1e\x00\xac\x00\xf9\x00\xdd\x00\x92\x00\x1f\x00\xee\x00\xf0\x00\xdc\x00\xde\x00\xdf\x00\xed\x00\xec\x00\xe4\x00\xe9\x00\xc1\x00\xa6\x00\xc5\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xe6\x00\xe5\x00\xf4\x00\xfd\x00\xf6\x00\xe7\x00\x1b\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xe0\x00\x23\x00\xe1\x00\xf2\x00\xae\x00\x24\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xe2\x00\xf1\x00\xe3\x00\xef\x00\xac\x00\xac\x00\xac\x00\xac\x00\xac\x00\x22\x00\x25\x00\x20\x00\x4e\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x26\x00\x45\x00\x2f\x00\x30\x00\x31\x00\x28\x00\x33\x00\x2d\x00\x32\x00\x37\x00\xac\x00\xf9\x00\xdd\x00\x92\x00\x0b\x00\xee\x00\xf0\x00\xdc\x00\xde\x00\xdf\x00\xed\x00\xec\x00\xe4\x00\xe9\x00\xc1\x00\xa6\x00\xc5\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xc3\x00\xe6\x00\xe5\x00\xf4\x00\xfd\x00\xf6\x00\xe7\x00\x36\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xe0\x00\x38\x00\xe1\x00\xf2\x00\xae\x00\x34\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x03\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xe2\x00\xf1\x00\xe3\x00\xef\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x71\x00\x3d\x00\x3e\x00\x3f\x00\x39\x00\x3c\x00\x43\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x40\x00\x46\x00\x47\x00\x44\x00\xbb\x00\x4b\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x4a\x00\x48\x00\x4c\x00\x4f\x00\x50\x00\x51\x00\x55\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x56\x00\x57\x00\x58\x00\x5c\x00\xbb\x00\x5d\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x04\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x62\x00\x5e\x00\x60\x00\x66\x00\x65\x00\x67\x00\x68\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x6c\x00\x6d\x00\x6e\x00\x72\x00\xbb\x00\x76\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x05\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x79\x00\x74\x00\x77\x00\x7a\x00\x7d\x00\x7e\x00\x7f\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x80\x00\x81\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x06\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xff\xff\xea\x00\x03\x01\x05\x01\xbb\x00\x08\x01\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x07\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xa8\x00\xa8\x00\xa8\x00\xcf\x00\xcb\x00\xa7\x00\xd4\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x0b\x01\x09\x01\xcf\x00\xcb\x00\xbb\x00\xd4\x00\x08\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xfe\x00\xcb\x00\xd0\x00\xd0\x00\xda\x00\xfc\x00\xd5\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xcb\x00\xd0\x00\xd0\x00\xda\x00\xbb\x00\xd5\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x09\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xf3\x00\xff\x00\xd5\x00\xff\xff\xff\xff\x0a\x01\x0c\x01\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x4d\x00\xd5\x00\x53\x00\x5a\x00\xbb\x00\x63\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x02\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x49\x00\x54\x00\x35\x00\x27\x00\x41\x00\x21\x00\x64\x00\x6a\x00\x0c\x00\x70\x00\x7b\x00\x17\x00\xff\xff\x78\x00\xff\xff\x7c\x00\x5b\x00\x3b\x00\x3a\x00\x75\x00\x12\x00\x61\x00\xff\xff\xff\xff\x00\x00\x52\x00\x42\x00\x59\x00\x5f\x00\x91\x00\x69\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x83\x00\xff\xff\x84\x00\x95\x00\x8c\x00\x8b\x00\x8c\x00\x8c\x00\x8c\x00\xff\xff\x83\x00\x84\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\x8b\x00\xff\xff\x8b\x00\xff\xff\x87\x00\xf7\x00\x8c\x00\x8b\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x6f\x00\x88\x00\x73\x00\x82\x00\xf8\x00\x96\x00\x07\x01\x8b\x00\x00\x01\xf5\x00\x00\x00\x01\x01\x00\x00\x97\x00\x00\x00\x96\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x02\x01\xe8\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8f\x00\x8f\x00\x8f\x00\x8f\x00\x8f\x00\x90\x00\x8f\x00\x90\x00\x90\x00\x90\x00\x90\x00\x8f\x00\x90\x00\x90\x00\x90\x00\xa3\x00\xa2\x00\xa3\x00\xa3\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x94\x00\xfb\x00\x00\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x00\x00\xff\xff\x00\x00\x00\x00\xa3\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x8e\x00\x97\x00\x9e\x00\x9e\x00\x9e\x00\x9e\x00\x9e\x00\x9f\x00\x9e\x00\x9f\x00\x9f\x00\x9f\x00\xa9\x00\xfa\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x9e\x00\x9e\x00\x9e\x00\x9e\x00\x9e\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x9a\x00\x00\x00\x00\x00\x9f\x00\x04\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x9f\x00\x9e\x00\x9f\x00\x9f\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\x9f\x00\x00\x00\x00\x00\xa2\x00\xa2\x00\xa2\x00\xa2\x00\xa2\x00\x00\x00\x00\x00\x00\x00\xac\x00\xac\x00\xac\x00\xac\x00\xac\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa2\x00\x00\x00\x00\x00\xa3\x00\xa2\x00\xa3\x00\xa3\x00\xa3\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa3\x00\xeb\x00\x00\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb0\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb1\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb2\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb3\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb4\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb5\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb6\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb7\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xb8\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\xbe\x00\x00\x00\xc7\x00\xbc\x00\x00\x00\xce\x00\xd3\x00\x00\x00\xd9\x00\xbc\x00\x00\x00\x00\x00\xc7\x00\xbc\x00\xcb\x00\xd0\x00\x00\x00\xd5\x00\x00\x00\xbc\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x00\xbc\x00\x00\x00\xce\x00\xd3\x00\x00\x00\xd9\x00\xbc\x00\xbc\x00\x00\x00\xc7\x00\xbc\x00\xcb\x00\xd0\x00\xbc\x00\xd5\x00\x00\x00\xbc\x00\x00\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\x00\x00\xbc\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\xbc\x00\xbd\x00\x00\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\x00\x00\xc9\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\xbc\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\xcc\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\xc4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x00\x00\x00\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\xcc\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc2\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\x00\x00\x00\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\x00\x00\x00\x00\xdb\x00\xbd\x00\x00\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc6\x00\xc2\x00\xc2\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\x00\x00\xd2\x00\xdb\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\xd1\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x00\x00\xca\x00\x00\x00\xd1\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xc0\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++alex_check :: AlexAddr+alex_check = AlexA# "\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x64\x00\x3a\x00\x74\x00\x3a\x00\x69\x00\x6e\x00\x74\x00\x6c\x00\x3a\x00\x64\x00\x6e\x00\x6e\x00\x74\x00\x3a\x00\x69\x00\x69\x00\x74\x00\x6e\x00\x20\x00\x21\x00\x22\x00\x23\x00\x74\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\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\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x3a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x6f\x00\x5d\x00\x5e\x00\x5f\x00\x61\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x6c\x00\x74\x00\x3a\x00\x65\x00\x75\x00\x62\x00\x6c\x00\x65\x00\x3a\x00\x75\x00\x6f\x00\x75\x00\x62\x00\x6f\x00\x65\x00\x3a\x00\x6c\x00\x61\x00\x20\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\x2d\x00\x2e\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\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x68\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x72\x00\x5d\x00\x5e\x00\x5f\x00\x3a\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x6d\x00\x69\x00\x6e\x00\x67\x00\x3a\x00\x72\x00\x70\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x3a\x00\x6e\x00\x63\x00\x3a\x00\x5f\x00\x67\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x72\x00\x3a\x00\x73\x00\x63\x00\x6c\x00\x3a\x00\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x63\x00\x6c\x00\x3a\x00\x75\x00\x5f\x00\x6d\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x63\x00\x3a\x00\x3a\x00\x63\x00\x65\x00\x6c\x00\x3a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x65\x00\x6d\x00\x3a\x00\x3a\x00\x5f\x00\x79\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x65\x00\x3a\x00\x3a\x00\x63\x00\x61\x00\x72\x00\x61\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x6d\x00\x3a\x00\x0a\x00\x0a\x00\x5f\x00\x0a\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x0a\x00\x2e\x00\x3d\x00\x3d\x00\x5f\x00\x3d\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2a\x00\x2a\x00\x2a\x00\x4c\x00\x4c\x00\x2f\x00\x4c\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x3c\x00\x3d\x00\x6c\x00\x6c\x00\x5f\x00\x6c\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3d\x00\x55\x00\x55\x00\x4c\x00\x4c\x00\x3d\x00\x55\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x75\x00\x75\x00\x6c\x00\x6c\x00\x5f\x00\x75\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3c\x00\x3d\x00\x4c\x00\x0a\x00\x0a\x00\x3d\x00\x3e\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x3a\x00\x6c\x00\x3a\x00\x3a\x00\x5f\x00\x3a\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\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x61\x00\x64\x00\x63\x00\x64\x00\x65\x00\x66\x00\x64\x00\x3a\x00\x69\x00\x3a\x00\x3a\x00\x6c\x00\x0a\x00\x70\x00\x0a\x00\x70\x00\x6e\x00\x74\x00\x73\x00\x74\x00\x75\x00\x73\x00\x0a\x00\x0a\x00\xff\xff\x73\x00\x78\x00\x73\x00\x73\x00\x65\x00\x73\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x22\x00\x0a\x00\x22\x00\x6e\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x22\x00\x22\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x20\x00\x0a\x00\x22\x00\x2b\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x73\x00\x22\x00\x73\x00\x73\x00\x2d\x00\x22\x00\x3d\x00\x20\x00\x3d\x00\x3e\x00\xff\xff\x3d\x00\xff\xff\x22\x00\xff\xff\x22\x00\xff\xff\x20\x00\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x69\x00\x7c\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x0a\x00\xff\xff\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x22\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2a\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2f\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\x20\x00\x3d\x00\x22\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6c\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\x46\x00\xff\xff\x4c\x00\x4c\x00\xff\xff\x4c\x00\x4c\x00\xff\xff\xff\xff\x45\x00\x46\x00\x55\x00\x55\x00\xff\xff\x55\x00\xff\xff\x4c\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x6c\x00\x6c\x00\xff\xff\x6c\x00\x6c\x00\x46\x00\xff\xff\x65\x00\x66\x00\x75\x00\x75\x00\x4c\x00\x75\x00\xff\xff\x6c\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x66\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6c\x00\x4c\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x6c\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x55\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x55\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\xff\xff\xff\xff\x58\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\x4c\x00\x78\x00\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x55\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x75\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\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\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#++alex_deflt :: AlexAddr+alex_deflt = AlexA# "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x85\x00\x86\x00\x85\x00\x86\x00\x89\x00\x8a\x00\x89\x00\x8a\x00\xff\xff\xab\x00\xff\xff\xab\x00\xff\xff\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\x98\x00\x99\x00\x98\x00\x99\x00\x9c\x00\x9d\x00\x9c\x00\x9d\x00\xff\xff\xab\x00\xff\xff\xab\x00\xff\xff\xab\x00\xa5\x00\xa5\x00\xff\xff\xff\xff\xaa\x00\xaa\x00\xaa\x00\xab\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#++alex_accept = listArray (0::Int,268) [[],[],[(AlexAccPred (alex_action_0) ( allowAnti )),(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAccPred (alex_action_1) ( allowAnti ))],[(AlexAccPred (alex_action_31) ( allowAnti ))],[],[],[(AlexAccPred (alex_action_2) ( allowAnti ))],[],[],[(AlexAccPred (alex_action_3) ( allowAnti ))],[],[],[],[],[(AlexAccPred (alex_action_4) ( allowAnti ))],[],[],[],[],[(AlexAccPred (alex_action_5) ( allowAnti ))],[],[],[],[],[(AlexAccPred (alex_action_6) ( allowAnti ))],[],[],[],[],[],[(AlexAccPred (alex_action_7) ( allowAnti ))],[],[],[],[],[],[],[(AlexAccPred (alex_action_8) ( allowAnti ))],[],[],[],[],[],[],[(AlexAccPred (alex_action_9) ( allowAnti ))],[],[],[],[],[(AlexAccPred (alex_action_10) ( allowAnti ))],[],[],[],[],[],[],[(AlexAccPred (alex_action_11) ( allowAnti ))],[],[],[],[(AlexAccPred (alex_action_12) ( allowAnti ))],[],[],[],[(AlexAccPred (alex_action_13) ( allowAnti ))],[],[],[],[],[(AlexAccPred (alex_action_14) ( allowAnti ))],[],[],[],[(AlexAccPred (alex_action_15) ( allowAnti ))],[],[(AlexAccPred (alex_action_16) ( allowAnti ))],[],[],[],[],[(AlexAccPred (alex_action_17) ( allowAnti ))],[],[(AlexAccPred (alex_action_18) ( allowAnti ))],[],[],[],[(AlexAccPred (alex_action_19) ( allowAnti ))],[],[(AlexAccPred (alex_action_20) ( allowAnti ))],[],[],[(AlexAccPred (alex_action_21) ( allowAnti ))],[],[],[],[],[(AlexAccPred (alex_action_22) ( allowAnti ))],[],[(AlexAccPred (alex_action_23) ( allowAnti ))],[],[],[],[(AlexAccPred (alex_action_24) ( allowAnti ))],[],[(AlexAccPred (alex_action_25) ( allowAnti ))],[],[(AlexAccPred (alex_action_26) ( allowAnti ))],[],[(AlexAccPred (alex_action_27) ( allowAnti ))],[],[],[(AlexAccPred (alex_action_28) ( allowAnti ))],[],[],[],[(AlexAccPred (alex_action_29) ( allowAnti ))],[],[],[],[],[],[(AlexAccPred (alex_action_30) ( allowAnti ))],[],[(AlexAccPred (alex_action_32) (alexPrevCharIs '\n'))],[(AlexAccPred (alex_action_32) (alexPrevCharIs '\n')),(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccPred (alex_action_32) (alexPrevCharIs '\n'))],[(AlexAccPred (alex_action_32) (alexPrevCharIs '\n')),(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccPred (alex_action_33) (alexPrevCharIs '\n'))],[(AlexAccPred (alex_action_33) (alexPrevCharIs '\n')),(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccPred (alex_action_33) (alexPrevCharIs '\n'))],[(AlexAccPred (alex_action_33) (alexPrevCharIs '\n')),(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_62))],[(AlexAccSkip)],[],[],[],[(AlexAccSkipPred (alexPrevCharIs '\n'))],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_40))],[(AlexAcc (alex_action_40))],[(AlexAcc (alex_action_40))],[(AlexAcc (alex_action_40))],[(AlexAcc (alex_action_40))],[(AlexAcc (alex_action_56))],[],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_42))],[],[],[],[],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_43))],[(AlexAcc (alex_action_43))],[(AlexAcc (alex_action_43))],[(AlexAcc (alex_action_43))],[(AlexAcc (alex_action_43))],[(AlexAcc (alex_action_43))],[],[(AlexAcc (alex_action_44))],[(AlexAcc (alex_action_45))],[(AlexAcc (alex_action_46))],[(AlexAcc (alex_action_47))],[(AlexAcc (alex_action_48))],[(AlexAcc (alex_action_49))],[(AlexAcc (alex_action_50))],[(AlexAcc (alex_action_51))],[(AlexAcc (alex_action_52))],[(AlexAcc (alex_action_53))],[(AlexAcc (alex_action_54))],[(AlexAcc (alex_action_55))],[(AlexAcc (alex_action_57))],[(AlexAcc (alex_action_60))],[(AlexAcc (alex_action_58))],[],[(AlexAcc (alex_action_59))],[(AlexAcc (alex_action_61))],[(AlexAcc (alex_action_63))],[(AlexAcc (alex_action_64))],[(AlexAcc (alex_action_65))],[(AlexAcc (alex_action_66))],[(AlexAcc (alex_action_67))],[(AlexAcc (alex_action_68))],[(AlexAcc (alex_action_77))],[(AlexAcc (alex_action_69))],[(AlexAcc (alex_action_78))],[(AlexAcc (alex_action_70))],[(AlexAcc (alex_action_71))],[(AlexAcc (alex_action_72))],[(AlexAcc (alex_action_73))],[(AlexAcc (alex_action_74))],[(AlexAcc (alex_action_75))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_76))],[(AlexAcc (alex_action_79))],[(AlexAcc (alex_action_80))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_84))],[(AlexAcc (alex_action_85))],[(AlexAcc (alex_action_86))],[(AlexAcc (alex_action_87))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_91))],[(AlexAccPred (alex_action_92) ( ifExtension cudaExts ))],[(AlexAccPred (alex_action_93) ( ifExtension cudaExts ))]]+{-# LINE 218 "Language/C/Parser/Lexer.x" #-}++charEscapes :: [(Char, Char)]+charEscapes = [('n', '\n'),+ ('t', '\t'),+ ('v', '\v'),+ ('b', '\b'),+ ('r', '\r'),+ ('f', '\f'),+ ('a', '\a'),+ ('\\', '\\'),+ ('?', '?'),+ ('\'', '\''),+ ('\"', '\"')+ ]++type Action = Pos -> B.ByteString -> Int -> P (L Token)++setLineFromPragma :: Action+setLineFromPragma pos buf len = do+ setPos pos'+ lexToken+ where+ (_ : l : ws) = (words . B.unpack . B.take len) buf+ line = read l - 1+ filename = (takeWhile (/= '\"') . drop 1 . concat . intersperse " ") ws++ pos' :: Pos+ pos' = Pos (intern filename) line 1 (posCoff pos)++locateTok :: Pos -> Token -> P (L Token)+locateTok end tok = do+ start <- getLastPos+ setLastPos end+ return $ L (Loc start end) tok++token :: Token -> Action+token tok pos buf len =+ locateTok pos tok++identifier :: Action+identifier pos buf len =+ case Map.lookup kw keywordMap of+ Nothing -> nonKeyword+ Just (tok, Nothing) -> keyword tok+ Just (tok, Just i) -> do isKw <- useExts i+ if isKw then keyword tok else nonKeyword+ where+ kw = (B.unpack . B.take len) buf++ keyword tok = locateTok pos tok++ nonKeyword = do+ test <- isTypedef kw+ if test+ then locateTok pos (Tnamed kw)+ else locateTok pos (Tidentifier kw)++lexAnti ::(String -> Token) -> Action+lexAnti antiTok pos buf len = do+ c <- alexGetCharOrFail+ s <- case c of+ '(' -> lexExpression 0 ""+ _ | isIdStartChar c -> lexIdChars [c]+ | otherwise -> illegalCharacterLiteral pos+ end <- getPos+ locateTok end (antiTok s)+ where+ lexIdChars :: String -> P String+ lexIdChars s = do+ inp <- getInput+ maybe_c <- alexMaybeGetChar+ case maybe_c of+ Nothing -> return (reverse s)+ Just c | isIdChar c -> lexIdChars (c : s)+ | otherwise -> setInput inp >> return (reverse s)++ lexExpression :: Int -> String -> P String+ lexExpression depth s = do+ inp <- getInput+ maybe_c <- alexMaybeGetChar+ case maybe_c of+ Nothing -> return (reverse s)+ Just '(' -> lexExpression (depth+1) ('(' : s)+ Just ')' | depth == 0 -> return (reverse s)+ | otherwise -> lexExpression (depth-1) (')' : s)+ Just c -> lexExpression depth (c : s)++ isIdStartChar :: Char -> Bool+ isIdStartChar '_' = True+ isIdStartChar c = isLower c++ isIdChar :: Char -> Bool+ isIdChar '_' = True+ isIdChar '\'' = True+ isIdChar c = isAlphaNum c++lexCharTok :: Action+lexCharTok pos buf len = do+ c <- alexGetCharOrFail+ case c of+ '\'' -> emptyCharacterLiteral pos+ '\\' -> do c <- lexEscape+ quote <- alexGetCharOrFail+ when (quote /= '\'') $+ illegalCharacterLiteral pos+ end <- getPos+ raw <- liftM ('\'' :) (getBuffRange pos end)+ locateTok end (TcharConst (raw, c))+ _ -> do quote <- alexGetCharOrFail+ when (quote /= '\'') $+ illegalCharacterLiteral pos+ end <- getPos+ raw <- liftM ('\'' :) (getBuffRange pos end)+ locateTok end (TcharConst (raw, c))++lexStringTok :: Action+lexStringTok pos buf len = do+ s <- lexString ""+ end <- getPos+ raw <- liftM ('"' :) (getBuffRange pos end)+ locateTok end (TstringConst (raw, s))+ where+ lexString :: String -> P String+ lexString s = do+ c <- alexGetCharOrFail+ case c of+ '"' -> return (reverse s)+ '\\' -> do c' <- lexEscape+ lexString (c' : s)+ _ -> lexString (c : s)++lexEscape :: P Char+lexEscape = do+ inp <- getInput+ c <- alexGetCharOrFail+ case c of+ 'x' -> do i <- checkedReadNum isHexDigit 16 hexDigit+ return $ chr i+ n | isDigit n ->+ do setInput inp+ i <- checkedReadNum isOctDigit 8 octDigit+ return $ chr i+ c -> case lookup c charEscapes of+ Nothing -> return c+ Just c' -> return c'++type Radix = (Integer, Char -> Int)++decDigit :: Char -> Int+decDigit c | c >= '0' && c <= '9' = ord c - ord '0'+ | otherwise = error "error in decimal constant"++octDigit :: Char -> Int+octDigit c | c >= '0' && c <= '7' = ord c - ord '0'+ | otherwise = error "error in octal constant"++hexDigit :: Char -> Int+hexDigit c | c >= 'a' && c <= 'f' = ord c - ord 'a'+ | c >= 'A' && c <= 'F' = ord c - ord 'A'+ | c >= '0' && c <= '9' = ord c - ord '0'+ | otherwise = error "error in hexadecimal constant"++decimal :: Radix+decimal = (10, decDigit)++octal :: Radix+octal = (8, octDigit)++hexadecimal :: Radix+hexadecimal = (16, hexDigit)++readInteger :: Radix -> ReadS Integer+readInteger (radix, charToInt) =+ go 0+ where+ go :: Integer -> ReadS Integer+ go x [] = return (x, "")+ go x (c : cs) | isDigit c = go (x * radix + toInteger (charToInt c)) cs+ | otherwise = return (x, c : cs)++readRational :: ReadS Rational+readRational s = do+ (n, d, t) <- readFix s+ (x, u) <- readExponent t+ return ((n % 1) * 10^^(x - toInteger d), t)+ where+ readFix :: String -> [(Integer, Int, String)]+ readFix s =+ return (read (i ++ f), length f, u)+ where+ (i, t) = span isDigit s+ (f, u) = case t of+ '.' : u -> span isDigit u+ _ -> ("", t)++ readExponent :: ReadS Integer+ readExponent "" = return (0, "")+ readExponent (e : s) | e `elem` "eE" = go s+ | otherwise = return (0, s)+ where+ go :: ReadS Integer+ go ('+' : s) = readDecimal s+ go ('-' : s) = do (x, t) <- readDecimal s+ return (-x, t)+ go s = readDecimal s++ readDecimal :: ReadS Integer+ readDecimal = readInteger decimal++lexInteger :: Int+ -> Radix+ -> Action+lexInteger ndrop radix pos buf len =+ case i of+ [n] -> locateTok pos (toToken n)+ _ -> fail "bad parse for integer"+ where+ num :: String+ num = (takeWhile isDigit . drop ndrop) s++ suffix :: String+ suffix = (map toLower . takeWhile (not . isDigit) . reverse) s++ s :: String+ s = (B.unpack . B.take len) buf++ i :: [Integer]+ i = do (n, _) <- readInteger radix s+ return n++ toToken :: Integer -> Token+ toToken n =+ case numElls of+ 0 -> TintConst (s, isUnsigned, n)+ 1 -> TlongIntConst (s, isUnsigned, n)+ 2 -> TlongLongIntConst (s, isUnsigned, n)+ where+ numElls :: Int+ numElls = (length . filter (== 'l')) suffix++ isUnsigned :: C.Signed+ isUnsigned = if 'u' `elem` suffix then C.Unsigned else C.Signed++lexFloat :: Action+lexFloat pos buf len =+ case i of+ [n] -> locateTok pos (toToken n)+ _ -> fail "bad parse for integer"+ where+ s :: String+ s = (B.unpack . B.take len) buf++ prefix :: String+ prefix = takeWhile (not . isSuffix) s++ suffix :: String+ suffix = (map toLower . takeWhile isSuffix . reverse) s++ isSuffix :: Char -> Bool+ isSuffix = (`elem` ['l', 'L', 'f', 'F'])++ i :: [Rational]+ i = do (n, _) <- readRational s+ return n++ toToken :: Rational -> Token+ toToken n =+ case suffix of+ "" -> TdoubleConst (s, n)+ "f" -> TfloatConst (s, n)+ "l" -> TlongDoubleConst (s, n)++checkedReadNum :: (Char -> Bool) -> Int -> (Char -> Int) -> P Int+checkedReadNum isDigit base conv = do+ c <- alexGetCharOrFail+ when (not $ isDigit c) $+ getPos >>= illegalNumericalLiteral+ readNum isDigit base conv+ where+ readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> P Int+ readNum isDigit base conv = read 0+ where+ read :: Int -> P Int+ read i = do+ inp <- getInput+ c <- alexGetCharOrFail+ if isDigit c+ then read (i*base + conv c)+ else setInput inp >> return i++lexToken :: P (L Token)+lexToken = do+ inp@(AlexInput pos buf off) <- getInput+ sc <- getLexState+ st <- get+ case alexScanUser st inp sc of+ AlexEOF -> return $ L (Loc pos pos) Teof+ AlexError (AlexInput pos2 _ _) ->+ lexerError pos2 ((text . B.unpack . B.take (min 80 (B.length rest))) rest)+ where+ rest = B.drop off buf+ AlexSkip inp2 _ -> do+ setInput inp2+ pos <- getPos+ setLastPos pos+ lexToken+ AlexToken inp2@(AlexInput end _ _) len t -> do+ setInput inp2+ t end (B.drop off buf) len++emptyCharacterLiteral :: Pos -> P a+emptyCharacterLiteral pos =+ throw $ ParserException (getLoc pos) (text "empty character literal")++illegalCharacterLiteral :: Pos -> P a+illegalCharacterLiteral pos =+ throw $ ParserException (getLoc pos) (text "illegal character literal")++illegalNumericalLiteral :: Pos -> P a+illegalNumericalLiteral pos =+ throw $ ParserException (getLoc pos) (text "illegal numerical literal")++lexerError :: Pos -> Doc -> P a+lexerError pos s =+ throw $ ParserException (getLoc pos) (text "lexer error on" <+> squotes s)+++qq :: Int+qq = 1+alex_action_0 = token Ttypename +alex_action_1 = lexAnti Tanti_id +alex_action_2 = lexAnti Tanti_int +alex_action_3 = lexAnti Tanti_uint +alex_action_4 = lexAnti Tanti_lint +alex_action_5 = lexAnti Tanti_ulint +alex_action_6 = lexAnti Tanti_float +alex_action_7 = lexAnti Tanti_double +alex_action_8 = lexAnti Tanti_long_double +alex_action_9 = lexAnti Tanti_char +alex_action_10 = lexAnti Tanti_string +alex_action_11 = lexAnti Tanti_exp +alex_action_12 = lexAnti Tanti_func +alex_action_13 = lexAnti Tanti_args +alex_action_14 = lexAnti Tanti_decl +alex_action_15 = lexAnti Tanti_decls +alex_action_16 = lexAnti Tanti_sdecl +alex_action_17 = lexAnti Tanti_sdecls +alex_action_18 = lexAnti Tanti_enum +alex_action_19 = lexAnti Tanti_enums +alex_action_20 = lexAnti Tanti_esc +alex_action_21 = lexAnti Tanti_edecl +alex_action_22 = lexAnti Tanti_edecls +alex_action_23 = lexAnti Tanti_item +alex_action_24 = lexAnti Tanti_items +alex_action_25 = lexAnti Tanti_stm +alex_action_26 = lexAnti Tanti_stms +alex_action_27 = lexAnti Tanti_type +alex_action_28 = lexAnti Tanti_spec +alex_action_29 = lexAnti Tanti_param +alex_action_30 = lexAnti Tanti_params +alex_action_31 = lexAnti Tanti_exp +alex_action_32 = setLineFromPragma +alex_action_33 = setLineFromPragma +alex_action_39 = identifier +alex_action_40 = lexFloat +alex_action_41 = lexInteger 0 decimal +alex_action_42 = lexInteger 1 octal +alex_action_43 = lexInteger 2 hexadecimal +alex_action_44 = lexCharTok +alex_action_45 = lexStringTok +alex_action_46 = token Tlparen +alex_action_47 = token Trparen +alex_action_48 = token Tlbrack +alex_action_49 = token Trbrack +alex_action_50 = token Tlbrace +alex_action_51 = token Trbrace +alex_action_52 = token Tcomma +alex_action_53 = token Tsemi +alex_action_54 = token Tcolon +alex_action_55 = token Tquestion +alex_action_56 = token Tdot +alex_action_57 = token Tarrow +alex_action_58 = token Tellipses +alex_action_59 = token Tplus +alex_action_60 = token Tminus +alex_action_61 = token Tstar +alex_action_62 = token Tdiv +alex_action_63 = token Tmod +alex_action_64 = token Tnot +alex_action_65 = token Tand +alex_action_66 = token Tor +alex_action_67 = token Txor +alex_action_68 = token Tlsh +alex_action_69 = token Trsh +alex_action_70 = token Tinc +alex_action_71 = token Tdec +alex_action_72 = token Tlnot +alex_action_73 = token Tland +alex_action_74 = token Tlor +alex_action_75 = token Teq +alex_action_76 = token Tne +alex_action_77 = token Tlt +alex_action_78 = token Tgt +alex_action_79 = token Tle +alex_action_80 = token Tge +alex_action_81 = token Tassign +alex_action_82 = token Tadd_assign +alex_action_83 = token Tsub_assign +alex_action_84 = token Tmul_assign +alex_action_85 = token Tdiv_assign +alex_action_86 = token Tmod_assign +alex_action_87 = token Tand_assign +alex_action_88 = token Tor_assign +alex_action_89 = token Txor_assign +alex_action_90 = token Tlsh_assign +alex_action_91 = token Trsh_assign +alex_action_92 = token T3lt +alex_action_93 = token T3gt +{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "<built-in>" #-}+{-# LINE 1 "<command-line>" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- -----------------------------------------------------------------------------+-- ALEX TEMPLATE+--+-- This code is in the PUBLIC DOMAIN; you may copy it freely and use+-- it for any purpose whatsoever.++-- -----------------------------------------------------------------------------+-- INTERNALS and main scanner engine++{-# LINE 37 "templates/GenericTemplate.hs" #-}++{-# LINE 47 "templates/GenericTemplate.hs" #-}+++data AlexAddr = AlexA# Addr#++#if __GLASGOW_HASKELL__ < 503+uncheckedShiftL# = shiftL#+#endif++{-# INLINE alexIndexInt16OffAddr #-}+alexIndexInt16OffAddr (AlexA# arr) off =+#ifdef WORDS_BIGENDIAN+ narrow16Int# i+ where+ i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)+ high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+ low = int2Word# (ord# (indexCharOffAddr# arr off'))+ off' = off *# 2#+#else+ indexInt16OffAddr# arr off+#endif++++++{-# INLINE alexIndexInt32OffAddr #-}+alexIndexInt32OffAddr (AlexA# arr) off = +#ifdef WORDS_BIGENDIAN+ narrow32Int# i+ where+ i = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`+ (b2 `uncheckedShiftL#` 16#) `or#`+ (b1 `uncheckedShiftL#` 8#) `or#` b0)+ b3 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))+ b2 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))+ b1 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+ b0 = int2Word# (ord# (indexCharOffAddr# arr off'))+ off' = off *# 4#+#else+ indexInt32OffAddr# arr off+#endif++++++#if __GLASGOW_HASKELL__ < 503+quickIndex arr i = arr ! i+#else+-- GHC >= 503, unsafeAt is available from Data.Array.Base.+quickIndex = unsafeAt+#endif+++++-- -----------------------------------------------------------------------------+-- Main lexing routines++data AlexReturn a+ = AlexEOF+ | AlexError !AlexInput+ | AlexSkip !AlexInput !Int+ | AlexToken !AlexInput !Int a++-- alexScan :: AlexInput -> StartCode -> AlexReturn a+alexScan input (I# (sc))+ = alexScanUser undefined input (I# (sc))++alexScanUser user input (I# (sc))+ = case alex_scan_tkn user input 0# input sc AlexNone of+ (AlexNone, input') ->+ case alexGetChar input of+ Nothing -> ++++ AlexEOF+ Just _ ->++++ AlexError input'++ (AlexLastSkip input'' len, _) ->++++ AlexSkip input'' len++ (AlexLastAcc k input''' len, _) ->++++ AlexToken input''' len k+++-- Push the input through the DFA, remembering the most recent accepting+-- state it encountered.++alex_scan_tkn user orig_input len input s last_acc =+ input `seq` -- strict in the input+ let + new_acc = check_accs (alex_accept `quickIndex` (I# (s)))+ in+ new_acc `seq`+ case alexGetChar input of+ Nothing -> (new_acc, input)+ Just (c, new_input) -> ++++ let+ !(base) = alexIndexInt32OffAddr alex_base s+ !((I# (ord_c))) = ord c+ !(offset) = (base +# ord_c)+ !(check) = alexIndexInt16OffAddr alex_check offset+ + !(new_s) = if (offset >=# 0#) && (check ==# ord_c)+ then alexIndexInt16OffAddr alex_table offset+ else alexIndexInt16OffAddr alex_deflt s+ in+ case new_s of + -1# -> (new_acc, input)+ -- on an error, we want to keep the input *before* the+ -- character that failed, not after.+ _ -> alex_scan_tkn user orig_input (len +# 1#) + new_input new_s new_acc++ where+ check_accs [] = last_acc+ check_accs (AlexAcc a : _) = AlexLastAcc a input (I# (len))+ check_accs (AlexAccSkip : _) = AlexLastSkip input (I# (len))+ check_accs (AlexAccPred a predx : rest)+ | predx user orig_input (I# (len)) input+ = AlexLastAcc a input (I# (len))+ check_accs (AlexAccSkipPred predx : rest)+ | predx user orig_input (I# (len)) input+ = AlexLastSkip input (I# (len))+ check_accs (_ : rest) = check_accs rest++data AlexLastAcc a+ = AlexNone+ | AlexLastAcc a !AlexInput !Int+ | AlexLastSkip !AlexInput !Int++data AlexAcc a user+ = AlexAcc a+ | AlexAccSkip+ | AlexAccPred a (AlexAccPred user)+ | AlexAccSkipPred (AlexAccPred user)++type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool++-- -----------------------------------------------------------------------------+-- Predicates on a rule++alexAndPred p1 p2 user in1 len in2+ = p1 user in1 len in2 && p2 user in1 len in2++--alexPrevCharIsPred :: Char -> AlexAccPred _ +alexPrevCharIs c _ input _ _ = c == alexInputPrevChar input++--alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _ +alexPrevCharIsOneOf arr _ input _ _ = arr ! alexInputPrevChar input++--alexRightContext :: Int -> AlexAccPred _+alexRightContext (I# (sc)) user _ _ input = + case alex_scan_tkn user input 0# input sc AlexNone of+ (AlexNone, _) -> False+ _ -> True+ -- TODO: there's no need to find the longest+ -- match when checking the right context, just+ -- the first match will do.++-- used by wrappers+iUnbox (I# (i)) = i
+ dist/build/Language/C/Parser/Parser.hs view
@@ -0,0 +1,6361 @@+{-# OPTIONS_GHC -fno-warn-overlapping-patterns #-}+{-# OPTIONS -fglasgow-exts -cpp #-}+{-# OPTIONS -w #-}++-- Copyright (c) 2006-2010+-- The President and Fellows of Harvard College.+--+-- Redistribution and use in source and binary forms, with or without+-- modification, are permitted provided that the following conditions+-- are met:+-- 1. Redistributions of source code must retain the above copyright+-- notice, this list of conditions and the following disclaimer.+-- 2. Redistributions in binary form must reproduce the above copyright+-- notice, this list of conditions and the following disclaimer in the+-- documentation and/or other materials provided with the distribution.+-- 3. Neither the name of the University nor the names of its contributors+-- may be used to endorse or promote products derived from this software+-- without specific prior written permission.++-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND+-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+-- ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+-- SUCH DAMAGE.++--------------------------------------------------------------------------------+-- |+-- Module : Language.C.Parser.Parser+-- Copyright : (c) Harvard University 2006-2010+-- License : BSD-style+-- Maintainer : mainland@eecs.harvard.edu+--+--------------------------------------------------------------------------------++module Language.C.Parser.Parser where++import Control.Monad (forM_,+ when)+import Control.Monad.Exception+import Data.List (intersperse)+import Data.Loc+import Data.Maybe (catMaybes)+import Text.PrettyPrint.Mainland++import Language.C.Parser.Lexer+import Language.C.Parser.Monad+import qualified Language.C.Parser.Tokens as T+import Language.C.Pretty+import Language.C.Syntax+import qualified Language.C.Syntax as C+import qualified Data.Array as Happy_Data_Array+import qualified GHC.Exts as Happy_GHC_Exts++-- parser produced by Happy Version 1.18.5++newtype HappyAbsSyn = HappyAbsSyn HappyAny+#if __GLASGOW_HASKELL__ >= 607+type HappyAny = Happy_GHC_Exts.Any+#else+type HappyAny = forall a . a+#endif+happyIn14 :: (Id) -> (HappyAbsSyn )+happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn14 #-}+happyOut14 :: (HappyAbsSyn ) -> (Id)+happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut14 #-}+happyIn15 :: (Id) -> (HappyAbsSyn )+happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn15 #-}+happyOut15 :: (HappyAbsSyn ) -> (Id)+happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut15 #-}+happyIn16 :: (Const) -> (HappyAbsSyn )+happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn16 #-}+happyOut16 :: (HappyAbsSyn ) -> (Const)+happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut16 #-}+happyIn17 :: (Exp) -> (HappyAbsSyn )+happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn17 #-}+happyOut17 :: (HappyAbsSyn ) -> (Exp)+happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut17 #-}+happyIn18 :: (RevList (L (String, String))) -> (HappyAbsSyn )+happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn18 #-}+happyOut18 :: (HappyAbsSyn ) -> (RevList (L (String, String)))+happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut18 #-}+happyIn19 :: (Exp) -> (HappyAbsSyn )+happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn19 #-}+happyOut19 :: (HappyAbsSyn ) -> (Exp)+happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut19 #-}+happyIn20 :: (ExeConfig) -> (HappyAbsSyn )+happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn20 #-}+happyOut20 :: (HappyAbsSyn ) -> (ExeConfig)+happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut20 #-}+happyIn21 :: (RevList Exp) -> (HappyAbsSyn )+happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn21 #-}+happyOut21 :: (HappyAbsSyn ) -> (RevList Exp)+happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut21 #-}+happyIn22 :: (Exp) -> (HappyAbsSyn )+happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn22 #-}+happyOut22 :: (HappyAbsSyn ) -> (Exp)+happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut22 #-}+happyIn23 :: (Exp) -> (HappyAbsSyn )+happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn23 #-}+happyOut23 :: (HappyAbsSyn ) -> (Exp)+happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut23 #-}+happyIn24 :: (Exp) -> (HappyAbsSyn )+happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn24 #-}+happyOut24 :: (HappyAbsSyn ) -> (Exp)+happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut24 #-}+happyIn25 :: (Exp) -> (HappyAbsSyn )+happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn25 #-}+happyOut25 :: (HappyAbsSyn ) -> (Exp)+happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut25 #-}+happyIn26 :: (Exp) -> (HappyAbsSyn )+happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn26 #-}+happyOut26 :: (HappyAbsSyn ) -> (Exp)+happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut26 #-}+happyIn27 :: (Exp) -> (HappyAbsSyn )+happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn27 #-}+happyOut27 :: (HappyAbsSyn ) -> (Exp)+happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut27 #-}+happyIn28 :: (Exp) -> (HappyAbsSyn )+happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn28 #-}+happyOut28 :: (HappyAbsSyn ) -> (Exp)+happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut28 #-}+happyIn29 :: (Exp) -> (HappyAbsSyn )+happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn29 #-}+happyOut29 :: (HappyAbsSyn ) -> (Exp)+happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut29 #-}+happyIn30 :: (Exp) -> (HappyAbsSyn )+happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn30 #-}+happyOut30 :: (HappyAbsSyn ) -> (Exp)+happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut30 #-}+happyIn31 :: (Exp) -> (HappyAbsSyn )+happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn31 #-}+happyOut31 :: (HappyAbsSyn ) -> (Exp)+happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut31 #-}+happyIn32 :: (Exp) -> (HappyAbsSyn )+happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn32 #-}+happyOut32 :: (HappyAbsSyn ) -> (Exp)+happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut32 #-}+happyIn33 :: (Exp) -> (HappyAbsSyn )+happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn33 #-}+happyOut33 :: (HappyAbsSyn ) -> (Exp)+happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut33 #-}+happyIn34 :: (Exp) -> (HappyAbsSyn )+happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn34 #-}+happyOut34 :: (HappyAbsSyn ) -> (Exp)+happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut34 #-}+happyIn35 :: (Exp) -> (HappyAbsSyn )+happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn35 #-}+happyOut35 :: (HappyAbsSyn ) -> (Exp)+happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut35 #-}+happyIn36 :: (Exp) -> (HappyAbsSyn )+happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn36 #-}+happyOut36 :: (HappyAbsSyn ) -> (Exp)+happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut36 #-}+happyIn37 :: (Maybe Exp) -> (HappyAbsSyn )+happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn37 #-}+happyOut37 :: (HappyAbsSyn ) -> (Maybe Exp)+happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut37 #-}+happyIn38 :: (Exp) -> (HappyAbsSyn )+happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn38 #-}+happyOut38 :: (HappyAbsSyn ) -> (Exp)+happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut38 #-}+happyIn39 :: (InitGroup) -> (HappyAbsSyn )+happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn39 #-}+happyOut39 :: (HappyAbsSyn ) -> (InitGroup)+happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut39 #-}+happyIn40 :: (InitGroup) -> (HappyAbsSyn )+happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn40 #-}+happyOut40 :: (HappyAbsSyn ) -> (InitGroup)+happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut40 #-}+happyIn41 :: ((DeclSpec, Decl)) -> (HappyAbsSyn )+happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn41 #-}+happyOut41 :: (HappyAbsSyn ) -> ((DeclSpec, Decl))+happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut41 #-}+happyIn42 :: ((DeclSpec, Decl)) -> (HappyAbsSyn )+happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn42 #-}+happyOut42 :: (HappyAbsSyn ) -> ((DeclSpec, Decl))+happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut42 #-}+happyIn43 :: ((DeclSpec, Decl)) -> (HappyAbsSyn )+happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn43 #-}+happyOut43 :: (HappyAbsSyn ) -> ((DeclSpec, Decl))+happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut43 #-}+happyIn44 :: ([TySpec]) -> (HappyAbsSyn )+happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn44 #-}+happyOut44 :: (HappyAbsSyn ) -> ([TySpec])+happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut44 #-}+happyIn45 :: ([TySpec]) -> (HappyAbsSyn )+happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn45 #-}+happyOut45 :: (HappyAbsSyn ) -> ([TySpec])+happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut45 #-}+happyIn46 :: (RevList Init) -> (HappyAbsSyn )+happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn46 #-}+happyOut46 :: (HappyAbsSyn ) -> (RevList Init)+happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut46 #-}+happyIn47 :: (Maybe AsmLabel) -> (HappyAbsSyn )+happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn47 #-}+happyOut47 :: (HappyAbsSyn ) -> (Maybe AsmLabel)+happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut47 #-}+happyIn48 :: (Init) -> (HappyAbsSyn )+happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn48 #-}+happyOut48 :: (HappyAbsSyn ) -> (Init)+happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut48 #-}+happyIn49 :: (TySpec) -> (HappyAbsSyn )+happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn49 #-}+happyOut49 :: (HappyAbsSyn ) -> (TySpec)+happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut49 #-}+happyIn50 :: (TySpec) -> (HappyAbsSyn )+happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn50 #-}+happyOut50 :: (HappyAbsSyn ) -> (TySpec)+happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut50 #-}+happyIn51 :: (TySpec) -> (HappyAbsSyn )+happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn51 #-}+happyOut51 :: (HappyAbsSyn ) -> (TySpec)+happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut51 #-}+happyIn52 :: (L (Maybe Id -> Maybe [FieldGroup] -> [Attr] -> SrcLoc -> TySpec)) -> (HappyAbsSyn )+happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn52 #-}+happyOut52 :: (HappyAbsSyn ) -> (L (Maybe Id -> Maybe [FieldGroup] -> [Attr] -> SrcLoc -> TySpec))+happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut52 #-}+happyIn53 :: (RevList FieldGroup) -> (HappyAbsSyn )+happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn53 #-}+happyOut53 :: (HappyAbsSyn ) -> (RevList FieldGroup)+happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut53 #-}+happyIn54 :: (FieldGroup) -> (HappyAbsSyn )+happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn54 #-}+happyOut54 :: (HappyAbsSyn ) -> (FieldGroup)+happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut54 #-}+happyIn55 :: ([TySpec]) -> (HappyAbsSyn )+happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn55 #-}+happyOut55 :: (HappyAbsSyn ) -> ([TySpec])+happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut55 #-}+happyIn56 :: ([TySpec]) -> (HappyAbsSyn )+happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn56 #-}+happyOut56 :: (HappyAbsSyn ) -> ([TySpec])+happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut56 #-}+happyIn57 :: (RevList Field) -> (HappyAbsSyn )+happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn57 #-}+happyOut57 :: (HappyAbsSyn ) -> (RevList Field)+happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut57 #-}+happyIn58 :: (Field) -> (HappyAbsSyn )+happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn58 #-}+happyOut58 :: (HappyAbsSyn ) -> (Field)+happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut58 #-}+happyIn59 :: (TySpec) -> (HappyAbsSyn )+happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn59 #-}+happyOut59 :: (HappyAbsSyn ) -> (TySpec)+happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut59 #-}+happyIn60 :: (RevList CEnum) -> (HappyAbsSyn )+happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn60 #-}+happyOut60 :: (HappyAbsSyn ) -> (RevList CEnum)+happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut60 #-}+happyIn61 :: (CEnum) -> (HappyAbsSyn )+happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn61 #-}+happyOut61 :: (HappyAbsSyn ) -> (CEnum)+happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut61 #-}+happyIn62 :: (TySpec) -> (HappyAbsSyn )+happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn62 #-}+happyOut62 :: (HappyAbsSyn ) -> (TySpec)+happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut62 #-}+happyIn63 :: ((Id, Decl -> Decl)) -> (HappyAbsSyn )+happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn63 #-}+happyOut63 :: (HappyAbsSyn ) -> ((Id, Decl -> Decl))+happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut63 #-}+happyIn64 :: ((Id, Decl -> Decl)) -> (HappyAbsSyn )+happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn64 #-}+happyOut64 :: (HappyAbsSyn ) -> ((Id, Decl -> Decl))+happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut64 #-}+happyIn65 :: ((Id, Decl -> Decl)) -> (HappyAbsSyn )+happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn65 #-}+happyOut65 :: (HappyAbsSyn ) -> ((Id, Decl -> Decl))+happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut65 #-}+happyIn66 :: ((Id, Decl -> Decl)) -> (HappyAbsSyn )+happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn66 #-}+happyOut66 :: (HappyAbsSyn ) -> ((Id, Decl -> Decl))+happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut66 #-}+happyIn67 :: ((Id, Decl -> Decl)) -> (HappyAbsSyn )+happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn67 #-}+happyOut67 :: (HappyAbsSyn ) -> ((Id, Decl -> Decl))+happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut67 #-}+happyIn68 :: ((Id, Decl -> Decl)) -> (HappyAbsSyn )+happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn68 #-}+happyOut68 :: (HappyAbsSyn ) -> ((Id, Decl -> Decl))+happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut68 #-}+happyIn69 :: ((Id, Decl -> Decl)) -> (HappyAbsSyn )+happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn69 #-}+happyOut69 :: (HappyAbsSyn ) -> ((Id, Decl -> Decl))+happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut69 #-}+happyIn70 :: ((Id, Decl -> Decl)) -> (HappyAbsSyn )+happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn70 #-}+happyOut70 :: (HappyAbsSyn ) -> ((Id, Decl -> Decl))+happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut70 #-}+happyIn71 :: (Decl -> Decl) -> (HappyAbsSyn )+happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn71 #-}+happyOut71 :: (HappyAbsSyn ) -> (Decl -> Decl)+happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut71 #-}+happyIn72 :: (Decl -> Decl) -> (HappyAbsSyn )+happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn72 #-}+happyOut72 :: (HappyAbsSyn ) -> (Decl -> Decl)+happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut72 #-}+happyIn73 :: (RevList TySpec) -> (HappyAbsSyn )+happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn73 #-}+happyOut73 :: (HappyAbsSyn ) -> (RevList TySpec)+happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut73 #-}+happyIn74 :: (Params) -> (HappyAbsSyn )+happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn74 #-}+happyOut74 :: (HappyAbsSyn ) -> (Params)+happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut74 #-}+happyIn75 :: (RevList Param) -> (HappyAbsSyn )+happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn75 #-}+happyOut75 :: (HappyAbsSyn ) -> (RevList Param)+happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut75 #-}+happyIn76 :: (Param) -> (HappyAbsSyn )+happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn76 #-}+happyOut76 :: (HappyAbsSyn ) -> (Param)+happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut76 #-}+happyIn77 :: (Type) -> (HappyAbsSyn )+happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn77 #-}+happyOut77 :: (HappyAbsSyn ) -> (Type)+happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut77 #-}+happyIn78 :: (RevList Id) -> (HappyAbsSyn )+happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn78 #-}+happyOut78 :: (HappyAbsSyn ) -> (RevList Id)+happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut78 #-}+happyIn79 :: (Type) -> (HappyAbsSyn )+happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn79 #-}+happyOut79 :: (HappyAbsSyn ) -> (Type)+happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut79 #-}+happyIn80 :: (Decl -> Decl) -> (HappyAbsSyn )+happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn80 #-}+happyOut80 :: (HappyAbsSyn ) -> (Decl -> Decl)+happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut80 #-}+happyIn81 :: (Decl -> Decl) -> (HappyAbsSyn )+happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn81 #-}+happyOut81 :: (HappyAbsSyn ) -> (Decl -> Decl)+happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut81 #-}+happyIn82 :: (TySpec) -> (HappyAbsSyn )+happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn82 #-}+happyOut82 :: (HappyAbsSyn ) -> (TySpec)+happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut82 #-}+happyIn83 :: (Initializer) -> (HappyAbsSyn )+happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn83 #-}+happyOut83 :: (HappyAbsSyn ) -> (Initializer)+happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut83 #-}+happyIn84 :: (RevList (Maybe Designation, Initializer)) -> (HappyAbsSyn )+happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn84 #-}+happyOut84 :: (HappyAbsSyn ) -> (RevList (Maybe Designation, Initializer))+happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut84 #-}+happyIn85 :: (Designation) -> (HappyAbsSyn )+happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn85 #-}+happyOut85 :: (HappyAbsSyn ) -> (Designation)+happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut85 #-}+happyIn86 :: (RevList Designator) -> (HappyAbsSyn )+happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn86 #-}+happyOut86 :: (HappyAbsSyn ) -> (RevList Designator)+happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut86 #-}+happyIn87 :: (Designator) -> (HappyAbsSyn )+happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn87 #-}+happyOut87 :: (HappyAbsSyn ) -> (Designator)+happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut87 #-}+happyIn88 :: (Stm) -> (HappyAbsSyn )+happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn88 #-}+happyOut88 :: (HappyAbsSyn ) -> (Stm)+happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut88 #-}+happyIn89 :: (Stm) -> (HappyAbsSyn )+happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn89 #-}+happyOut89 :: (HappyAbsSyn ) -> (Stm)+happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut89 #-}+happyIn90 :: (Stm) -> (HappyAbsSyn )+happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn90 #-}+happyOut90 :: (HappyAbsSyn ) -> (Stm)+happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut90 #-}+happyIn91 :: (RevList BlockItem) -> (HappyAbsSyn )+happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn91 #-}+happyOut91 :: (HappyAbsSyn ) -> (RevList BlockItem)+happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut91 #-}+happyIn92 :: (BlockItem) -> (HappyAbsSyn )+happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn92 #-}+happyOut92 :: (HappyAbsSyn ) -> (BlockItem)+happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut92 #-}+happyIn93 :: (()) -> (HappyAbsSyn )+happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn93 #-}+happyOut93 :: (HappyAbsSyn ) -> (())+happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut93 #-}+happyIn94 :: (()) -> (HappyAbsSyn )+happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn94 #-}+happyOut94 :: (HappyAbsSyn ) -> (())+happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut94 #-}+happyIn95 :: (RevList InitGroup) -> (HappyAbsSyn )+happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn95 #-}+happyOut95 :: (HappyAbsSyn ) -> (RevList InitGroup)+happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut95 #-}+happyIn96 :: (Stm) -> (HappyAbsSyn )+happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn96 #-}+happyOut96 :: (HappyAbsSyn ) -> (Stm)+happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut96 #-}+happyIn97 :: (Stm) -> (HappyAbsSyn )+happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn97 #-}+happyOut97 :: (HappyAbsSyn ) -> (Stm)+happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut97 #-}+happyIn98 :: (Stm) -> (HappyAbsSyn )+happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn98 #-}+happyOut98 :: (HappyAbsSyn ) -> (Stm)+happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut98 #-}+happyIn99 :: (Stm) -> (HappyAbsSyn )+happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn99 #-}+happyOut99 :: (HappyAbsSyn ) -> (Stm)+happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut99 #-}+happyIn100 :: ([Definition]) -> (HappyAbsSyn )+happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn100 #-}+happyOut100 :: (HappyAbsSyn ) -> ([Definition])+happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut100 #-}+happyIn101 :: (RevList Definition) -> (HappyAbsSyn )+happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn101 #-}+happyOut101 :: (HappyAbsSyn ) -> (RevList Definition)+happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut101 #-}+happyIn102 :: (Definition) -> (HappyAbsSyn )+happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn102 #-}+happyOut102 :: (HappyAbsSyn ) -> (Definition)+happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut102 #-}+happyIn103 :: (Func) -> (HappyAbsSyn )+happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn103 #-}+happyOut103 :: (HappyAbsSyn ) -> (Func)+happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut103 #-}+happyIn104 :: ([Attr]) -> (HappyAbsSyn )+happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn104 #-}+happyOut104 :: (HappyAbsSyn ) -> ([Attr])+happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut104 #-}+happyIn105 :: ([Attr]) -> (HappyAbsSyn )+happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn105 #-}+happyOut105 :: (HappyAbsSyn ) -> ([Attr])+happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut105 #-}+happyIn106 :: (RevList Attr) -> (HappyAbsSyn )+happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn106 #-}+happyOut106 :: (HappyAbsSyn ) -> (RevList Attr)+happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut106 #-}+happyIn107 :: (Attr) -> (HappyAbsSyn )+happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn107 #-}+happyOut107 :: (HappyAbsSyn ) -> (Attr)+happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut107 #-}+happyIn108 :: (Id) -> (HappyAbsSyn )+happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn108 #-}+happyOut108 :: (HappyAbsSyn ) -> (Id)+happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut108 #-}+happyIn109 :: (Bool) -> (HappyAbsSyn )+happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn109 #-}+happyOut109 :: (HappyAbsSyn ) -> (Bool)+happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut109 #-}+happyIn110 :: (Stm) -> (HappyAbsSyn )+happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn110 #-}+happyOut110 :: (HappyAbsSyn ) -> (Stm)+happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut110 #-}+happyIn111 :: (RevList String) -> (HappyAbsSyn )+happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn111 #-}+happyOut111 :: (HappyAbsSyn ) -> (RevList String)+happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut111 #-}+happyIn112 :: ([(String, Exp)]) -> (HappyAbsSyn )+happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn112 #-}+happyOut112 :: (HappyAbsSyn ) -> ([(String, Exp)])+happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut112 #-}+happyIn113 :: (RevList (String, Exp)) -> (HappyAbsSyn )+happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn113 #-}+happyOut113 :: (HappyAbsSyn ) -> (RevList (String, Exp))+happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut113 #-}+happyIn114 :: ((String, Exp)) -> (HappyAbsSyn )+happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn114 #-}+happyOut114 :: (HappyAbsSyn ) -> ((String, Exp))+happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut114 #-}+happyIn115 :: ([String]) -> (HappyAbsSyn )+happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn115 #-}+happyOut115 :: (HappyAbsSyn ) -> ([String])+happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut115 #-}+happyIn116 :: (RevList String) -> (HappyAbsSyn )+happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn116 #-}+happyOut116 :: (HappyAbsSyn ) -> (RevList String)+happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut116 #-}+happyIn117 :: (String) -> (HappyAbsSyn )+happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn117 #-}+happyOut117 :: (HappyAbsSyn ) -> (String)+happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut117 #-}+happyInTok :: ((L T.Token)) -> (HappyAbsSyn )+happyInTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyInTok #-}+happyOutTok :: (HappyAbsSyn ) -> ((L T.Token))+happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOutTok #-}+++happyActOffsets :: HappyAddr+happyActOffsets = HappyA# "\xf2\x10\x6d\x07\x5d\x08\x19\x09\x53\x00\xad\x08\x7c\x06\xf6\x0f\xda\x03\x1d\x07\xad\x08\xc3\x04\x00\x00\x31\x01\x00\x00\x00\x00\x4f\x09\xf7\x16\xcf\x16\x00\x00\x27\x01\x00\x00\xf7\x16\xf7\x16\x3f\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\xc7\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\xa8\x04\x15\x01\x2e\x04\xcd\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x04\x00\x00\x00\x00\xb5\x04\x13\x02\x9b\x09\x00\x00\xec\x03\xf8\x03\xed\x03\x6e\x03\xd1\x03\x97\x04\x90\x04\x95\x04\x89\x04\xfa\xff\x00\x00\x00\x00\x27\x00\x23\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x02\x00\x00\x00\x00\xf2\x10\xf2\x10\xf2\x10\xf2\x10\xf2\x10\xb8\x10\xb8\x10\x91\x10\xb3\x01\x91\x10\x53\x01\x9a\x04\xda\x03\x9c\x04\x0d\x00\x9b\x04\x42\x0c\x57\x10\x91\x04\x8d\x04\x3c\x04\x81\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x04\xf5\x0d\x1b\x01\x07\x04\x00\x00\x1b\x01\x07\x04\x5b\x04\xf5\x03\x00\x00\x54\x17\xf5\x03\x18\x01\x00\x00\x50\x11\xd4\x07\x00\x00\x18\x01\x57\x00\xf5\x03\x15\x01\xf5\x03\x0b\x00\x30\x10\x00\x00\x75\x04\x00\x00\x00\x00\x9c\x03\x00\x00\x86\x03\x7d\x01\x6c\x01\xae\x00\x00\x00\x00\x00\x00\x00\x23\x01\x58\x03\x74\x04\x00\x00\x6c\x04\x00\x00\xdc\x03\x00\x00\x88\x00\x30\x10\xd4\x07\x54\x17\x00\x00\xd4\x07\xb6\x03\x50\x11\x00\x00\x50\x11\x30\x10\x00\x00\x00\x00\x64\x03\x00\x00\x00\x00\xfd\x00\x00\x00\x33\x03\x00\x00\x38\x04\x2b\x0b\x00\x00\x00\x00\x00\x00\x34\x01\xf6\x0f\x02\x00\x00\x00\x30\x10\x0c\x00\x30\x10\x6f\x04\x00\x00\x30\x10\x30\x10\x00\x00\xec\x02\x20\x00\x00\x00\x00\x00\x30\x10\xd2\x00\x00\x00\x8a\x00\x1c\x04\xda\x03\x00\x00\x00\x00\x00\x00\x00\x00\x65\x04\x00\x00\x00\x00\x00\x00\x00\x00\xec\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\xef\x03\xe2\x01\x78\x02\x67\x04\xe2\x01\xe2\x01\x00\x00\x00\x00\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\x30\x10\xbc\x09\x69\x0c\x57\x00\x57\x00\x00\x00\x00\x00\xfc\x0a\x00\x00\xda\x03\x00\x00\x00\x00\x05\x01\x00\x00\x00\x00\x00\x00\x63\x03\x00\x00\x63\x04\x54\x00\x2d\x00\x00\x00\x00\x00\x61\x04\x54\x00\xe3\x08\x00\x00\xcf\x16\xcf\x16\xcf\x16\x00\x00\xcf\x16\xf7\x16\x00\x00\x0d\x08\x00\x00\x00\x00\xbd\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x60\x04\x00\x00\xe3\x08\xa7\x03\x00\x00\x00\x00\x00\x00\x2d\x00\x62\x04\x4d\x02\x29\x04\x3e\x03\x00\x00\x4a\x04\x00\x00\x18\x00\x43\x04\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x02\x00\x00\xe4\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\x00\x00\x00\x00\xec\x03\xec\x03\x6b\x03\x6b\x03\x25\x03\x25\x03\x25\x03\x25\x03\x6e\x03\x6e\x03\xda\x02\x40\x04\x39\x04\x37\x04\x2d\x04\x1f\x03\x13\x03\x00\x00\x82\x05\x00\x00\x00\x00\x00\x00\xcf\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x02\x00\x00\x36\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x04\xda\x03\x00\x00\x33\x04\x2c\x04\x28\x04\x30\x10\x00\x00\x00\x00\x00\x00\x92\x03\x00\x00\x00\x00\x1b\x02\x79\x03\x27\x03\x35\x04\x1e\x04\x00\x00\x27\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x0b\x25\x04\xe0\x0c\x00\x00\x00\x00\x58\x0f\x57\x0d\xc8\x01\xfd\x00\x21\x04\x1b\x04\x00\x00\x37\x01\x38\x04\x00\x00\x00\x00\x00\x00\x2a\x06\x0d\x03\xd9\x02\xb6\x02\x00\x00\x2e\x05\x00\x00\x00\x00\x00\x00\xab\x00\x00\x00\xd4\x07\x00\x00\x00\x00\xc8\x03\x30\x10\x00\x00\x00\x00\x1a\x04\x00\x00\x58\x03\x99\x00\x13\x04\x03\x01\x00\x00\xdc\x04\x00\x00\x8a\x04\x96\x00\x00\x00\x00\x00\x00\x00\x17\x04\xd4\x02\x00\x00\x0f\x04\xd1\x02\x00\x00\x00\x00\x00\x00\x00\x00\x31\x11\x00\x00\x00\x00\x06\x04\x87\x02\x00\x00\x01\x04\x00\x00\x2a\x00\x00\x00\x00\x00\xd8\x05\x00\x00\xdb\x03\x00\x00\x00\x00\xf6\x03\x57\x0d\x00\x00\xee\x03\x00\x00\x31\x0f\x30\x10\x00\x00\x00\x00\xba\x0e\x00\x00\x00\x00\x00\x00\xad\x08\xd4\x01\x00\x00\x00\x00\xda\x03\x00\x00\xda\x03\x00\x00\xe7\x03\x00\x00\xda\x03\xdf\x03\x30\x10\x30\x10\x00\x00\xae\x03\x00\x00\x00\x00\xa5\x03\x00\x00\xf5\x0d\x30\x10\x00\x00\x00\x00\x83\x0a\x00\x00\x00\x00\xa4\x03\xa8\x03\x00\x00\x1c\x0e\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x2b\x00\xa7\x01\xe3\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0e\x8a\x03\xe3\x09\x00\x00\x00\x00\x00\x00\x45\x02\x00\x00\x19\x03\x77\x03\x93\x0e\x3c\x03\x00\x00\x00\x00\x00\x00\x68\x03\x4e\x03\x35\x03\x00\x00\x2c\x03\x00\x00\x00\x00\x26\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x47\x02\x00\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x0a\x1a\x03\x31\x11\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x01\x0c\x03\x00\x00\xd8\x02\x00\x00\xda\x03\x11\x02\xda\x03\xca\x0b\x00\x00\xfc\x02\x00\x00\x7e\x0d\x83\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x01\x00\x00\xda\x03\x00\x00\xda\x03\x00\x00\x30\x10\x05\x03\xca\x02\xc2\x02\x00\x00\x00\x00\xdd\x01\x00\x00\xaf\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\xda\x03\x00\x00\x00\x00\x94\x02\x93\x02\x50\x02\x3b\x02\x00\x00\x00\x00\x00\x00\x42\x02\x2c\x02\x00\x00\x00\x00\x00\x00"#++happyGotoOffsets :: HappyAddr+happyGotoOffsets = HappyA# "\x5c\x19\x95\x0a\x2e\x0e\x9e\x14\x8b\x01\xcd\x0e\x20\x13\xf0\x05\x8b\x14\xf5\x09\xe6\x03\x00\x00\x00\x00\x17\x03\x00\x00\x00\x00\x4c\x02\x27\x02\x38\x06\x00\x00\xb1\x00\x00\x00\x19\x02\x02\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x77\x04\x00\x00\xd0\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x15\xe1\x01\x00\x00\x21\x0c\xd7\x0b\x38\x0b\xf0\x09\x75\x09\x1c\x0a\xf7\x06\x3f\x09\x00\x00\x2f\x18\x00\x00\x00\x00\x32\x14\x00\x00\x1c\x02\x00\x00\x45\x19\xa5\x06\x00\x00\x00\x00\x9c\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\x90\x15\x54\x02\x00\x00\x00\x00\x95\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x07\x00\x00\xe1\x02\x00\x00\xdb\x02\x22\x02\x00\x00\x47\x01\x03\x02\x00\x00\xe5\x01\x00\x00\x00\x00\xff\x1a\x00\x00\x00\x00\x00\x00\x00\x00\xba\x01\x00\x00\xad\x01\x69\x01\x7e\x01\x17\x06\x00\x00\x00\x00\x00\x00\xf9\x01\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x01\x18\x18\x9a\x01\x0c\x04\x00\x00\xf6\x01\x00\x00\x28\x15\x00\x00\xe3\x14\x01\x18\x00\x00\x00\x00\x82\x01\x00\x00\x00\x00\xa8\x01\x00\x00\x71\x01\x00\x00\x08\x16\xf0\x16\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x05\x6b\x01\x00\x00\xea\x17\x89\x01\xe9\x1a\x00\x00\x00\x00\x2e\x19\x17\x19\x00\x00\xf0\x14\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\xf0\x15\x00\x00\x1b\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x11\x00\x00\x86\x02\x00\x00\x00\x00\x58\x02\xd2\x01\x00\x00\x00\x00\xe9\x18\xd8\x0d\x56\x0b\x14\x0f\xab\x09\xdd\x0a\x66\x0a\x3d\x0a\x73\x0c\x7e\x0b\x06\x0b\x8d\x0a\xc9\x0c\x4e\x0c\x2c\x08\x50\x06\x09\x09\xb9\x08\x69\x08\xd3\x1a\xbd\x1a\xa7\x1a\x91\x1a\x7b\x1a\x65\x1a\x4f\x1a\x39\x1a\x23\x1a\x0d\x1a\xf7\x19\xb5\x19\xd2\x18\x61\x01\x38\x01\x00\x00\x00\x00\x73\x19\x00\x00\x04\x14\x00\x00\x00\x00\x9c\x16\x00\x00\x00\x00\x00\x00\x83\x16\x00\x00\x00\x00\x29\x01\x87\x01\x00\x00\x00\x00\x00\x00\xe5\x00\xca\x11\x00\x00\x98\x04\xf9\x03\x52\x03\x00\x00\xfe\x02\xb2\x01\x00\x00\xdc\x0b\x00\x00\x00\x00\x7b\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x12\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x0c\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\xa5\x17\x00\x00\x00\x00\x00\x00\x79\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x13\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x15\x00\x00\x79\x17\x00\x00\x00\x00\xd8\x06\x3c\x11\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x0c\x00\x00\x00\x00\x00\x00\x5f\x08\x30\x01\x20\x01\x13\x01\x00\x00\x5c\x16\x00\x00\x00\x00\x00\x00\x5f\x07\x00\x00\xa8\x00\x00\x00\x00\x00\x5f\x00\xcb\x16\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x01\x00\x00\x00\x00\x6d\x00\x00\x00\x32\x16\x00\x00\x7e\x06\x0c\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x99\x12\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x63\x17\x00\x00\x00\x00\x00\x00\xd8\x06\xe1\x19\x00\x00\x00\x00\x4d\x05\x00\x00\x00\x00\x00\x00\xb0\x08\x00\x00\x00\x00\x00\x00\x94\x13\x00\x00\x7d\x13\x00\x00\x00\x00\x00\x00\x24\x13\x00\x00\x46\x18\xbb\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x15\x15\x1b\x00\x00\x00\x00\xcb\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x23\x12\x67\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x04\x00\x00\x9f\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\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\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x19\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x13\x00\x00\xf6\x12\x8d\x18\x00\x00\x00\x00\x00\x00\xa6\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x12\x00\x00\x86\x12\x00\x00\x76\x18\xdf\xff\x00\x00\x96\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x12\x00\x00\x00\x00\x00\x00\xc7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\xff\x00\x00\x00\x00\x00\x00\x00\x00"#++happyDefActions :: HappyAddr+happyDefActions = HappyA# "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\xfe\x00\x00\x00\x00\xf4\xff\x00\x00\x79\xff\x78\xff\x76\xff\x67\xff\x75\xff\x4b\xff\x00\x00\x4a\xff\x65\xff\x71\xff\x00\x00\xc1\xfe\x5a\xff\x53\xff\x19\xff\x4e\xff\x00\x00\x57\xff\x4f\xff\x18\xff\x51\xff\x50\xff\x59\xff\x17\xff\x52\xff\x4d\xff\x58\xff\x40\xff\x55\xff\x3f\xff\x4c\xff\x54\xff\x16\xff\x49\xff\x00\x00\x15\xff\x14\xff\x13\xff\x12\xff\x11\xff\x10\xff\x00\x00\x77\xff\x7b\xff\x6c\xfe\x00\x00\x00\x00\x00\x00\x72\xfe\x71\xfe\x6d\xfe\x6b\xfe\x7c\xff\x6a\xfe\x69\xfe\x70\xfe\xe0\xff\xdf\xff\xd7\xff\xde\xff\xc0\xff\xb4\xff\xb1\xff\xad\xff\xaa\xff\xa7\xff\xa2\xff\x9f\xff\x9d\xff\x9b\xff\x99\xff\x97\xff\x95\xff\x93\xff\x87\xff\x00\x00\x00\x00\xad\xfe\xac\xfe\xab\xfe\xaa\xfe\xa9\xfe\xa8\xfe\xa7\xfe\xea\xff\xd9\xff\xf0\xff\xef\xff\xee\xff\xed\xff\xec\xff\xeb\xff\x00\x00\x97\xfe\x91\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\x4d\xfe\x00\x00\xf3\xff\xe9\xff\xe8\xff\xe7\xff\xe6\xff\xe5\xff\xe4\xff\xe3\xff\xe2\xff\xe1\xff\xda\xff\xa6\xfe\xe0\xff\xbb\xfe\x00\x00\x00\x00\xdb\xfe\x00\x00\xd8\xfe\xd7\xfe\x00\x00\x1c\xff\x00\x00\x1a\xff\x30\xff\x00\x00\x00\x00\xe3\xfe\x00\x00\x34\xff\x37\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\xff\x7f\xff\x63\xff\xfd\xfe\x0f\xff\xfc\xfe\x06\xff\x00\x00\x00\x00\x80\xff\x66\xfe\x7d\xff\x04\xff\x00\x00\xe7\xfe\x00\x00\xf2\xff\x00\x00\xf1\xff\x00\x00\x2b\xff\x29\xff\x00\x00\x33\xff\x30\xff\xe2\xfe\x32\xff\x00\x00\x2f\xff\x36\xff\x2d\xff\x00\x00\xf3\xfe\xf2\xfe\xfb\xfe\xd6\xfe\xc7\xfe\xcc\xfe\xd5\xfe\xcb\xfe\xf9\xfe\x00\x00\x00\x00\xda\xfe\xd9\xfe\xb6\xfe\x00\x00\x00\x00\x00\x00\xb1\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x4c\xfe\x00\x00\x00\x00\xb7\xff\x00\x00\x00\x00\x76\xfe\x77\xfe\x00\x00\x00\x00\x7d\xfe\x00\x00\x00\x00\x00\x00\x7a\xfe\x7b\xfe\xb4\xff\x83\xff\x00\x00\x78\xfe\x79\xfe\xb8\xff\xbe\xff\x00\x00\xbf\xff\xbd\xff\xb9\xff\xbc\xff\xba\xff\xbb\xff\x00\x00\x00\x00\xd1\xfe\x00\x00\x00\x00\xd2\xfe\xce\xfe\x8f\xfe\x90\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\xff\xc9\xff\x00\x00\xd8\xff\x00\x00\x6f\xfe\x6e\xfe\x00\x00\x82\xff\xc0\xfe\xbf\xfe\x00\x00\x56\xff\x25\xff\x00\x00\x00\x00\x70\xff\x64\xff\x48\xff\x00\x00\x00\x00\x74\xff\x6d\xff\x6b\xff\x69\xff\x66\xff\x73\xff\x6f\xff\x7a\xff\x00\x00\x95\xfe\x68\xfe\x00\x00\x94\xfe\x6e\xff\x72\xff\x68\xff\x6a\xff\x6c\xff\x00\x00\x3e\xff\x3d\xff\x47\xff\x65\xfe\x00\x00\x00\x00\x21\xff\x20\xff\x24\xff\x00\x00\x00\x00\x00\x00\x5f\xff\x61\xff\x5b\xff\x00\x00\xa5\xfe\x00\x00\xc5\xff\xc4\xff\xc3\xff\xcb\xff\xcc\xff\x00\x00\xd6\xff\x00\x00\xd4\xff\xd3\xff\x89\xff\x88\xff\x8a\xff\x8b\xff\x8c\xff\x8f\xff\x90\xff\x91\xff\x8d\xff\x8e\xff\x92\xff\xae\xff\xaf\xff\xb0\xff\xab\xff\xac\xff\xa8\xff\xa9\xff\xa3\xff\xa4\xff\xa5\xff\xa6\xff\xa0\xff\xa1\xff\x9e\xff\x9c\xff\x9a\xff\x98\xff\x96\xff\x00\x00\xcc\xfe\xcd\xfe\x00\x00\xd0\xfe\xdb\xff\xb2\xff\x00\x00\xcf\xfe\xdc\xff\xdd\xff\x9d\xfe\x9c\xfe\x96\xfe\x9f\xfe\x00\x00\xa1\xfe\x9b\xfe\x99\xfe\x98\xfe\x9a\xfe\x00\x00\x00\x00\xa3\xfe\x00\x00\x84\xff\x00\x00\x85\xff\x85\xfe\x7c\xfe\x7e\xfe\x00\x00\x74\xfe\x75\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\xfe\x00\x00\xb0\xfe\xb2\xfe\xb5\xfe\xb9\xfe\xba\xfe\x00\x00\x00\x00\x00\x00\xf0\xfe\xf1\xfe\x00\x00\x00\x00\x00\x00\xcc\xfe\x00\x00\xe1\xfe\xdf\xfe\x00\x00\x00\x00\xc5\xfe\xde\xfe\xc6\xfe\x00\x00\x0e\xff\xfa\xfe\xca\xfe\xf7\xfe\x00\x00\x1b\xff\x2c\xff\x2e\xff\x00\x00\x39\xff\x31\xff\x35\xff\x27\xff\x28\xff\x00\x00\x3a\xff\x38\xff\x00\x00\xe5\xfe\xe6\xfe\x00\x00\x7e\xff\x05\xff\x01\xff\x00\x00\x0a\xff\x00\x00\x00\x00\x86\xff\x62\xff\xd4\xfe\x00\x00\x00\x00\x09\xff\x00\x00\x00\x00\x00\xff\x02\xff\x03\xff\xe4\xfe\x00\x00\x26\xff\x2a\xff\x00\x00\x00\x00\xf6\xfe\x00\x00\xc3\xfe\xcc\xfe\xc8\xfe\xc9\xfe\x00\x00\xc4\xfe\x00\x00\x0b\xff\x0c\xff\x00\x00\x00\x00\xe9\xfe\x00\x00\xef\xfe\x00\x00\x00\x00\xee\xfe\xb4\xfe\x00\x00\xb7\xfe\xb8\xfe\xaf\xfe\x00\x00\x00\x00\x47\xfe\x88\xfe\x00\x00\x8a\xfe\x00\x00\xb5\xff\xb6\xff\x8c\xfe\x00\x00\x00\x00\x85\xff\x00\x00\xa4\xfe\x00\x00\xa2\xfe\x9e\xfe\x00\x00\xb3\xff\x00\x00\x00\x00\xd2\xff\xd1\xff\x00\x00\xd5\xff\xd0\xff\x00\x00\x00\x00\x5e\xff\x00\x00\xbc\xfe\xbd\xfe\xbe\xfe\x00\x00\x23\xff\x1f\xff\x00\x00\x00\x00\x3c\xff\x45\xff\x46\xff\x3b\xff\x93\xfe\x67\xfe\x92\xfe\x00\x00\x43\xff\x44\xff\x1e\xff\x1d\xff\x22\xff\x5d\xff\x00\x00\x00\x00\x00\x00\xc2\xff\xc1\xff\x94\xff\x00\x00\xa0\xfe\x00\x00\x00\x00\x00\x00\x8e\xfe\x8b\xfe\x89\xfe\x46\xfe\x00\x00\x45\xfe\x00\x00\xb3\xfe\x00\x00\xe8\xfe\xed\xfe\x00\x00\xec\xfe\xf8\xfe\xdd\xfe\xe0\xfe\xdc\xfe\xc2\xfe\xf4\xfe\x00\x00\xf5\xfe\x5f\xfe\x00\x00\x63\xfe\x61\xfe\x59\xfe\x51\xfe\x58\xfe\x4f\xfe\x5d\xfe\x50\xfe\x5a\xfe\x52\xfe\x55\xfe\x5c\xfe\x54\xfe\x53\xfe\x5e\xfe\x5b\xfe\x56\xfe\x4e\xfe\x57\xfe\xfe\xfe\xff\xfe\x07\xff\x08\xff\x00\x00\x00\x00\x00\x00\xd3\xfe\xeb\xfe\xea\xfe\xc6\xff\x00\x00\x44\xfe\x43\xfe\x00\x00\x4b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x86\xfe\x00\x00\xc8\xff\x00\x00\x00\x00\xcf\xff\x60\xff\x5c\xff\x41\xff\x42\xff\xce\xff\xcd\xff\xc7\xff\x87\xfe\x00\x00\x82\xfe\x00\x00\x84\xfe\x00\x00\x8d\xfe\x00\x00\x00\x00\x00\x00\x45\xfe\x62\xfe\x64\xfe\x00\x00\x60\xfe\x00\x00\x4a\xfe\x42\xfe\x00\x00\x81\xfe\x83\xfe\x7f\xfe\x00\x00\x80\xfe\x41\xfe\x00\x00\x40\xfe\x00\x00\x3f\xfe\x3e\xfe\x3c\xfe\x49\xfe\x00\x00\x00\x00\x48\xfe\x3d\xfe"#++happyCheck :: HappyAddr+happyCheck = HappyA# "\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x00\x00\x14\x00\x0d\x00\x0f\x00\x10\x00\x67\x00\x12\x00\x00\x00\x09\x00\x09\x00\x15\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x11\x00\x09\x00\x1d\x00\x1e\x00\x00\x00\x27\x00\x00\x00\x01\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x01\x00\x0c\x00\x21\x00\x65\x00\x66\x00\x67\x00\x11\x00\x2e\x00\x11\x00\x12\x00\x09\x00\x09\x00\x0b\x00\x09\x00\x0d\x00\x11\x00\x12\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x64\x00\x43\x00\x44\x00\x45\x00\x46\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\x09\x00\x09\x00\x0a\x00\x5e\x00\x09\x00\x0a\x00\x61\x00\x62\x00\x63\x00\x5b\x00\x00\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x6d\x00\x6d\x00\x7a\x00\x7b\x00\x65\x00\x5c\x00\x5d\x00\x5e\x00\x6d\x00\x5a\x00\x5b\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x8b\x00\x6d\x00\x6d\x00\x00\x00\x6d\x00\x13\x00\x12\x00\x00\x00\x39\x00\x09\x00\x0a\x00\x0b\x00\x18\x00\x19\x00\x1a\x00\x0c\x00\x39\x00\x1d\x00\x1e\x00\x7e\x00\x7f\x00\x7e\x00\x7f\x00\x23\x00\x24\x00\x25\x00\x1a\x00\x00\x00\x01\x00\x5f\x00\x09\x00\x0a\x00\x0b\x00\x09\x00\x0a\x00\x0b\x00\x5b\x00\x0c\x00\x00\x00\x01\x00\x13\x00\x30\x00\x6d\x00\x6d\x00\x13\x00\x39\x00\x6d\x00\x1a\x00\x3c\x00\x3d\x00\x1a\x00\x3a\x00\x3b\x00\x41\x00\x2f\x00\x43\x00\x44\x00\x45\x00\x00\x00\x7e\x00\x00\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x30\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x39\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x12\x00\x00\x00\x01\x00\x5f\x00\x43\x00\x09\x00\x0a\x00\x61\x00\x62\x00\x63\x00\x00\x00\x0f\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x32\x00\x6d\x00\x7a\x00\x00\x00\x09\x00\x0a\x00\x0b\x00\x39\x00\x0d\x00\x5a\x00\x5b\x00\x5f\x00\x0b\x00\x0a\x00\x0d\x00\x87\x00\x88\x00\x43\x00\x0f\x00\x00\x00\x11\x00\x12\x00\x6d\x00\x5d\x00\x5e\x00\x6d\x00\x2e\x00\x2f\x00\x09\x00\x0a\x00\x0b\x00\x09\x00\x0a\x00\x0b\x00\x09\x00\x0a\x00\x0b\x00\x12\x00\x0d\x00\x00\x00\x01\x00\x13\x00\x09\x00\x0a\x00\x0b\x00\x1a\x00\x09\x00\x0a\x00\x1a\x00\x2e\x00\x00\x00\x1a\x00\x0f\x00\x00\x00\x00\x00\x01\x00\x09\x00\x0a\x00\x0b\x00\x1a\x00\x39\x00\x5f\x00\x5b\x00\x3c\x00\x3d\x00\x0c\x00\x10\x00\x11\x00\x41\x00\x00\x00\x43\x00\x44\x00\x45\x00\x1a\x00\x39\x00\x6d\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x4f\x00\x50\x00\x00\x00\x52\x00\x53\x00\x39\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x00\x00\x0a\x00\x00\x00\x01\x00\x5e\x00\x5f\x00\x12\x00\x10\x00\x62\x00\x63\x00\x39\x00\x6d\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x2b\x00\x2c\x00\x5f\x00\x09\x00\x0a\x00\x0b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x00\x00\x00\x7a\x00\x7b\x00\x3a\x00\x6d\x00\x61\x00\x5b\x00\x6d\x00\x5f\x00\x00\x00\x6d\x00\x00\x00\x21\x00\x00\x00\x87\x00\x88\x00\x11\x00\x12\x00\x6d\x00\x32\x00\x3c\x00\x3d\x00\x6d\x00\x00\x00\x37\x00\x41\x00\x39\x00\x43\x00\x30\x00\x45\x00\x5a\x00\x5b\x00\x6d\x00\x49\x00\x4a\x00\x4b\x00\x43\x00\x4d\x00\x3a\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x53\x00\x39\x00\x2e\x00\x56\x00\x57\x00\x58\x00\x59\x00\x32\x00\x0a\x00\x34\x00\x00\x00\x49\x00\x2e\x00\x2f\x00\x10\x00\x62\x00\x63\x00\x2f\x00\x39\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x5a\x00\x5b\x00\x12\x00\x31\x00\x32\x00\x00\x00\x0c\x00\x30\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x13\x00\x1f\x00\x7c\x00\x7d\x00\x0c\x00\x23\x00\x02\x00\x42\x00\x43\x00\x6d\x00\x32\x00\x5e\x00\x5f\x00\x87\x00\x88\x00\x37\x00\x0c\x00\x39\x00\x30\x00\x3c\x00\x3d\x00\x00\x00\x39\x00\x13\x00\x41\x00\x0c\x00\x43\x00\x43\x00\x45\x00\x0b\x00\x11\x00\x0d\x00\x49\x00\x4a\x00\x4b\x00\x39\x00\x4d\x00\x00\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x53\x00\x5f\x00\x1a\x00\x56\x00\x57\x00\x58\x00\x59\x00\x0c\x00\x0a\x00\x00\x00\x01\x00\x20\x00\x11\x00\x22\x00\x10\x00\x62\x00\x63\x00\x39\x00\x3a\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x42\x00\x43\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x00\x00\x00\x0c\x00\x0b\x00\x3a\x00\x0d\x00\x1f\x00\x11\x00\x7c\x00\x7d\x00\x23\x00\x30\x00\x0c\x00\x15\x00\x16\x00\x31\x00\x32\x00\x33\x00\x34\x00\x87\x00\x88\x00\x4f\x00\x3b\x00\x30\x00\x3a\x00\x3c\x00\x3d\x00\x23\x00\x24\x00\x1f\x00\x41\x00\x00\x00\x43\x00\x23\x00\x45\x00\x12\x00\x5a\x00\x5b\x00\x49\x00\x4a\x00\x4b\x00\x02\x00\x4d\x00\x1f\x00\x4f\x00\x50\x00\x30\x00\x23\x00\x53\x00\x11\x00\x00\x00\x56\x00\x57\x00\x58\x00\x59\x00\x30\x00\x0c\x00\x00\x00\x10\x00\x11\x00\x30\x00\x11\x00\x0c\x00\x62\x00\x63\x00\x0c\x00\x3b\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x24\x00\x25\x00\x26\x00\x0f\x00\x7c\x00\x7d\x00\x12\x00\x64\x00\x00\x00\x2d\x00\x10\x00\x11\x00\x18\x00\x19\x00\x1a\x00\x87\x00\x88\x00\x1d\x00\x1e\x00\x00\x00\x0c\x00\x31\x00\x32\x00\x23\x00\x24\x00\x25\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x0c\x00\x44\x00\x39\x00\x3a\x00\x0c\x00\x11\x00\x02\x00\x42\x00\x43\x00\x11\x00\x0e\x00\x42\x00\x43\x00\x11\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x12\x00\x43\x00\x44\x00\x45\x00\x46\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\x39\x00\x3a\x00\x0b\x00\x5e\x00\x0d\x00\x02\x00\x61\x00\x62\x00\x63\x00\x42\x00\x43\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x12\x00\x0c\x00\x7a\x00\x7b\x00\x0c\x00\x00\x00\x11\x00\x0b\x00\x0b\x00\x11\x00\x0d\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x62\x00\x63\x00\x64\x00\x0f\x00\x62\x00\x63\x00\x64\x00\x24\x00\x25\x00\x26\x00\x28\x00\x29\x00\x18\x00\x19\x00\x1a\x00\x02\x00\x2d\x00\x1d\x00\x1e\x00\x30\x00\x2b\x00\x2c\x00\x12\x00\x23\x00\x24\x00\x25\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x00\x00\x0b\x00\x00\x00\x0d\x00\x3a\x00\x1e\x00\x11\x00\x0b\x00\x44\x00\x0d\x00\x23\x00\x24\x00\x25\x00\x26\x00\x0c\x00\x0c\x00\x00\x00\x3c\x00\x3d\x00\x11\x00\x2d\x00\x0b\x00\x41\x00\x30\x00\x43\x00\x11\x00\x45\x00\x13\x00\x0c\x00\x0e\x00\x49\x00\x4a\x00\x4b\x00\x11\x00\x4d\x00\x0e\x00\x4f\x00\x50\x00\x51\x00\x0b\x00\x53\x00\x0d\x00\x0c\x00\x56\x00\x57\x00\x58\x00\x59\x00\x21\x00\x22\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x61\x00\x62\x00\x63\x00\x02\x00\x3a\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0b\x00\x1e\x00\x0d\x00\x1a\x00\x87\x00\x88\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x12\x00\x18\x00\x19\x00\x1a\x00\x42\x00\x2d\x00\x1d\x00\x1e\x00\x30\x00\x18\x00\x19\x00\x0c\x00\x23\x00\x24\x00\x25\x00\x12\x00\x11\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x0b\x00\x00\x00\x0d\x00\x2d\x00\x3d\x00\x0c\x00\x30\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5e\x00\x5f\x00\x0c\x00\x3c\x00\x3d\x00\x49\x00\x3b\x00\x11\x00\x41\x00\x4d\x00\x43\x00\x0b\x00\x45\x00\x0d\x00\x02\x00\x44\x00\x49\x00\x4a\x00\x4b\x00\x0b\x00\x4d\x00\x59\x00\x4f\x00\x50\x00\x51\x00\x10\x00\x53\x00\x10\x00\x11\x00\x56\x00\x57\x00\x58\x00\x59\x00\x0f\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x61\x00\x62\x00\x63\x00\x11\x00\x12\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x00\x00\x0b\x00\x0b\x00\x0c\x00\x0d\x00\x0f\x00\x87\x00\x88\x00\x12\x00\x11\x00\x12\x00\x00\x00\x0c\x00\x12\x00\x18\x00\x19\x00\x1a\x00\x11\x00\x0f\x00\x1d\x00\x1e\x00\x28\x00\x29\x00\x0c\x00\x0e\x00\x23\x00\x24\x00\x25\x00\x11\x00\x1b\x00\x1c\x00\x1d\x00\x0e\x00\x1f\x00\x1a\x00\x1b\x00\x1c\x00\x23\x00\x24\x00\x25\x00\x26\x00\x0c\x00\x21\x00\x22\x00\x18\x00\x19\x00\x0c\x00\x2d\x00\x3a\x00\x3b\x00\x30\x00\x1e\x00\x3e\x00\x3f\x00\x40\x00\x0c\x00\x23\x00\x24\x00\x25\x00\x26\x00\x46\x00\x47\x00\x48\x00\x0c\x00\x11\x00\x0b\x00\x2d\x00\x5f\x00\x4e\x00\x30\x00\x44\x00\x51\x00\x11\x00\x0c\x00\x54\x00\x11\x00\x24\x00\x25\x00\x26\x00\x0e\x00\x5a\x00\x0e\x00\x2a\x00\x02\x00\x5e\x00\x2d\x00\x12\x00\x61\x00\x30\x00\x11\x00\x0b\x00\x59\x00\x0c\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x10\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x1a\x00\x26\x00\x11\x00\x0b\x00\x1f\x00\x2e\x00\x00\x00\x20\x00\x02\x00\x03\x00\x04\x00\x05\x00\x1e\x00\x85\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\x0c\x00\x0f\x00\x0f\x00\x39\x00\x0f\x00\x0c\x00\x3c\x00\x3d\x00\x5a\x00\x00\x00\x13\x00\x41\x00\x0b\x00\x43\x00\x44\x00\x45\x00\x12\x00\x0b\x00\x8b\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x11\x00\x4f\x00\x50\x00\x2e\x00\x52\x00\x53\x00\x0b\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x8b\x00\x09\x00\x0a\x00\x59\x00\x0c\x00\x20\x00\x0b\x00\x22\x00\x62\x00\x63\x00\x0b\x00\x45\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x0b\x00\x0b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x13\x00\x8b\x00\x26\x00\x20\x00\x3a\x00\x5a\x00\x5b\x00\x1f\x00\x1e\x00\x1e\x00\x02\x00\x13\x00\x8b\x00\x12\x00\x23\x00\x24\x00\x25\x00\x26\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x39\x00\x0b\x00\x2d\x00\x3c\x00\x3d\x00\x30\x00\x02\x00\x8b\x00\x41\x00\x09\x00\x43\x00\x44\x00\x45\x00\xff\xff\x5a\x00\x5b\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x09\x00\x0a\x00\xff\xff\x0c\x00\xff\xff\xff\xff\xff\xff\x62\x00\x63\x00\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\x87\x00\x88\x00\x89\x00\x8a\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x09\x00\x0a\x00\xff\xff\x0c\x00\xff\xff\xff\xff\x45\x00\x62\x00\x63\x00\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x5b\x00\xff\xff\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\x87\x00\x88\x00\x89\x00\x8a\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x62\x00\x63\x00\x45\x00\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x1a\x00\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x87\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x45\x00\x62\x00\x63\x00\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x17\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\x87\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\x00\x00\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x0a\x00\x45\x00\x0c\x00\x20\x00\xff\xff\x22\x00\x62\x00\x63\x00\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\x00\x00\x3a\x00\x02\x00\x03\x00\x04\x00\x05\x00\x1e\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x23\x00\x24\x00\x25\x00\x26\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x39\x00\xff\xff\x2d\x00\x3c\x00\x3d\x00\x30\x00\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\x5b\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\x00\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x63\x00\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x2d\x00\xff\xff\x08\x00\x30\x00\xff\xff\xff\xff\x87\x00\x88\x00\x89\x00\x8a\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3c\x00\x3d\x00\x3e\x00\x41\x00\x40\x00\x43\x00\x44\x00\x45\x00\x44\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x0a\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x62\x00\x63\x00\x08\x00\x09\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x2d\x00\xff\xff\x08\x00\x30\x00\xff\xff\xff\xff\x87\x00\x88\x00\x89\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\x00\x00\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\x44\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x0a\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x62\x00\x63\x00\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\xff\xff\xff\xff\xff\xff\x78\x00\x3a\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\x88\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\x00\x00\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x0a\x00\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x62\x00\x63\x00\x08\x00\x09\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x78\x00\xff\xff\x7a\x00\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\x88\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\x62\x00\x63\x00\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\xff\xff\x78\x00\x30\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\x88\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\x3d\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x49\x00\xff\xff\x62\x00\x63\x00\x4d\x00\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x00\x00\x59\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x7a\x00\x7b\x00\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\x88\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x0a\x00\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x62\x00\x63\x00\x08\x00\x09\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x7a\x00\x7b\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\x88\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\x3c\x00\x3d\x00\x3e\x00\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\x44\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x0a\x00\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x62\x00\x63\x00\x08\x00\x09\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\x87\x00\x88\x00\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\x0a\x00\x41\x00\x3f\x00\x43\x00\x44\x00\x45\x00\xff\xff\x44\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x62\x00\x63\x00\x08\x00\x09\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\x3c\x00\x3d\x00\xff\xff\xff\xff\x0a\x00\x41\x00\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\x4d\x00\xff\xff\x4f\x00\x50\x00\x87\x00\x88\x00\x53\x00\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x62\x00\x63\x00\x08\x00\x09\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\x3c\x00\x3d\x00\xff\xff\xff\xff\x0a\x00\x41\x00\xff\xff\x43\x00\xff\xff\x45\x00\x7c\x00\x7d\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\x4d\x00\xff\xff\x4f\x00\x50\x00\x87\x00\x88\x00\x53\x00\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x62\x00\x63\x00\x08\x00\x09\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\x3c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\xff\xff\x45\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x87\x00\x88\x00\x53\x00\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x62\x00\x63\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x6c\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x18\x00\x19\x00\x1a\x00\x88\x00\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x61\x00\x02\x00\x03\x00\x04\x00\x05\x00\x2d\x00\xff\xff\x08\x00\x30\x00\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\x79\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x61\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x00\x00\x0b\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x00\x00\x0b\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\x79\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x61\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\xff\xff\x58\x00\x59\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x00\x00\x0b\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x00\x00\x0e\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\x51\x00\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x61\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x3d\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x49\x00\x79\x00\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\x51\x00\x52\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x59\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x0d\x00\xff\xff\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x4c\x00\x08\x00\x09\x00\x61\x00\xff\xff\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x12\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x00\x00\x0b\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\x00\x00\x61\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\x0e\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x1c\x00\x1d\x00\x2d\x00\x1f\x00\xff\xff\x30\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3b\x00\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\xff\xff\xff\xff\x44\x00\xff\xff\x49\x00\xff\xff\x39\x00\x3a\x00\x4d\x00\x3c\x00\x3d\x00\x3e\x00\x51\x00\x52\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\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\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x0d\x00\xff\xff\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x3d\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\x49\x00\x23\x00\x24\x00\x25\x00\x4d\x00\xff\xff\xff\xff\xff\xff\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x61\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x0d\x00\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x61\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\x0e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\x0e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\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\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\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\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\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\x61\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x61\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\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\x61\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x61\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\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\x61\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x51\x00\x18\x00\x19\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x51\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\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x39\x00\xff\xff\x30\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\x44\x00\x45\x00\x3b\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x4f\x00\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\x55\x00\xff\xff\x57\x00\x58\x00\x59\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\x4d\x00\x6d\x00\x4f\x00\x50\x00\xff\xff\xff\xff\x53\x00\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x63\x00\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x50\x00\x44\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x60\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\xff\xff\xff\xff\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\xff\xff\x50\x00\x44\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x60\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\x4a\x00\x4b\x00\x4c\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3e\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x60\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\x4a\x00\x4b\x00\x4c\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3e\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x60\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x60\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x60\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x24\x00\x25\x00\x26\x00\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x4a\x00\x4b\x00\x4c\x00\x2d\x00\x3b\x00\xff\xff\x30\x00\xff\xff\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x41\x00\xff\xff\xff\xff\x44\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x4c\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\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x3b\x00\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\x44\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x4c\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\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x3b\x00\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\x44\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x4c\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\x45\x00\x46\x00\x47\x00\x48\x00\x49\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\x45\x00\x46\x00\x47\x00\x48\x00\x49\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\x45\x00\xff\xff\x47\x00\x48\x00\x49\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x17\x00\x00\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x44\x00\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x2d\x00\xff\xff\x08\x00\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\x21\x00\x3b\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x41\x00\xff\xff\xff\xff\x44\x00\xff\xff\x2d\x00\xff\xff\x00\x00\x30\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x44\x00\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x51\x00\xff\xff\xff\xff\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x5a\x00\x5b\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\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x43\x00\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\xff\xff\x4f\x00\x50\x00\x30\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\x62\x00\xff\xff\xff\xff\x3d\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\x55\x00\xff\xff\xff\xff\xff\xff\x59\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\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\xff\xff\x30\x00\xff\xff\x41\x00\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\x4d\x00\xff\xff\x4f\x00\x50\x00\xff\xff\xff\xff\x53\x00\xff\xff\x30\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x44\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\x00\x00\x18\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\x00\x00\x18\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\x00\x00\x18\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\x00\x00\x18\x00\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x17\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x17\x00\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x07\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x07\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\x07\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\x00\x00\xff\xff\x02\x00\x03\x00\x04\x00\x05\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x9a\x01\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x1a\x00\x6b\x00\xea\x00\x07\x01\xdc\x00\x6c\x00\x96\xfe\xbc\x02\x6d\x00\x33\x01\x0d\x00\x0d\x00\xdd\x00\x29\x02\x6e\x00\x6f\x00\x70\x00\xa9\x00\x0d\x00\x71\x00\x72\x00\xaa\x01\x08\x01\xb9\x00\x63\x02\x73\x00\x74\x00\x75\x00\x05\x01\xb9\x00\x35\x01\xb2\x02\x2b\x02\xb4\x02\xb5\x02\xb6\x02\xa9\x00\xb4\x01\xa9\x00\xab\x01\x0d\x00\x0d\x00\xc5\x01\x0d\x00\xd4\x00\xa9\x00\x06\x01\x1b\x00\x76\x00\x77\x00\x1c\x00\x1d\x00\x78\x00\x79\x00\x7a\x00\x1e\x00\xaa\x02\x1f\x00\x20\x00\x21\x00\x7b\x00\x7c\x00\x7d\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x7e\x00\x27\x00\x28\x00\x7f\x00\x29\x00\x2a\x00\x80\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x81\x00\x0d\x00\x0d\x00\xbc\x00\x82\x00\x0d\x00\xbc\x00\x83\x00\x30\x00\x31\x00\x53\x01\x7f\x02\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x84\x00\x84\x00\x43\x00\x9b\x01\x2a\x02\x64\x02\x65\x02\x66\x02\x84\x00\x36\x01\xb3\x00\x9c\x01\x9d\x01\x8f\x00\x9e\x01\x39\x00\x3a\x00\xa6\x01\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x1a\x00\x6b\x00\xff\xff\x84\x00\x84\x00\xef\x01\x84\x00\xd8\x01\x85\xff\x98\x00\xcc\x01\x0d\x00\xb6\x00\xb7\x00\x6e\x00\x6f\x00\x70\x00\xf0\x01\xe0\x01\x71\x00\x72\x00\x9b\x00\x41\x02\x9b\x00\x58\x01\x73\x00\x74\x00\x75\x00\xb8\x00\xb9\x00\x3a\x01\xb9\x00\x0d\x00\xb6\x00\xb7\x00\x0d\x00\xb6\x00\xb7\x00\x53\x01\xb3\x02\xb9\x00\x63\x02\xc0\x00\x9e\x00\x84\x00\x84\x00\xb4\x02\x1b\x00\x84\x00\xb8\x00\x1c\x00\x1d\x00\xb8\x00\xdb\x01\xdc\x01\x1e\x00\x3f\x02\x1f\x00\x20\x00\x21\x00\xa9\x00\x9b\x00\xa7\x01\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\xc2\x00\x27\x00\x28\x00\x7f\x00\x29\x00\x2a\x00\xcd\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\xa8\x01\xb9\x00\x52\x01\xb9\x00\xcb\x01\x0d\x00\xbc\x00\x83\x00\x30\x00\x31\x00\x98\x00\x38\x01\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xc9\x01\x84\x00\x43\x00\x5f\x01\x0d\x00\xd2\x00\xd3\x00\xcd\x00\xd4\x00\x3b\x01\xb3\x00\xb9\x00\xe2\x01\x1a\x00\xd4\x00\x39\x00\x3a\x00\xcb\x01\x6c\x00\xb5\x00\x61\xff\x61\xff\x84\x00\xa4\x02\x66\x02\x84\x00\x30\x02\x56\x01\x0d\x00\xb6\x00\xb7\x00\x0d\x00\xb6\x00\xb7\x00\x0d\x00\xd2\x00\xd3\x00\x81\xff\xd4\x00\xb9\x00\x58\x01\xc0\x00\x0d\x00\xb6\x00\xb7\x00\xb8\x00\x0d\x00\xbc\x00\xb8\x00\x61\xff\xb6\x01\xb8\x00\x3d\x01\xfb\x01\xb9\x00\x65\x01\x0d\x00\xb6\x00\xb7\x00\xb8\x00\x1b\x00\xb9\x00\x53\x01\x1c\x00\x1d\x00\xfc\x01\xb7\x01\xb8\x01\x1e\x00\xa9\x00\x1f\x00\x20\x00\x21\x00\xb8\x00\xc7\x01\x84\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\xee\x00\x27\x00\x28\x00\x95\x02\x29\x00\x2a\x00\xcc\x01\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\xa9\x00\x1a\x00\xb9\x00\x66\x01\x60\x01\xb9\x00\xef\x00\x96\x02\x30\x00\x31\x00\xe2\x01\x84\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xbc\x00\xbd\x00\xb9\x00\x0d\x00\xb6\x00\xb7\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xbe\x00\x5f\x01\xa9\x00\x43\x00\x4a\x01\xb1\x00\x84\x00\x0f\x02\x53\x01\x84\x00\xb9\x00\x98\x00\x84\x00\xb0\x01\x5c\x01\x98\x00\x39\x00\x3a\x00\x61\xff\x61\xff\x84\x00\xc9\x01\x1c\x00\x1d\x00\x84\x00\xa9\x00\xfe\x01\x1e\x00\xcd\x00\x1f\x00\xc2\x00\x21\x00\xd6\x01\xb3\x00\x84\x00\x22\x00\x23\x00\x24\x00\xcb\x01\x26\x00\xf0\x01\x27\x00\x28\x00\x3e\x02\xa9\x00\x2a\x00\xc7\x01\x61\xff\x2c\x00\x2d\x00\x2e\x00\x2f\x00\xc9\x01\x1a\x00\xdf\x01\xf3\x00\xb2\x01\x55\x01\x56\x01\x3f\x02\x30\x00\x31\x00\x99\x00\xcc\x01\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x5d\x01\xb3\x00\xf4\x00\xc9\x00\xad\x00\x00\x02\xa3\x02\xc2\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xa4\x02\x4a\x01\xa2\x00\x39\x02\x01\x02\x11\x00\x52\x02\xcf\x00\xd0\x00\x84\x00\xc9\x01\x60\x01\xb9\x00\xa3\x00\xa4\x00\xca\x01\x53\x02\xcd\x00\x16\x00\x1c\x00\x1d\x00\xa9\x00\xe0\x01\x54\x02\x1e\x00\xa8\x02\x1f\x00\xcb\x01\x21\x00\x8d\x01\x27\x02\xd4\x00\x22\x00\x23\x00\x24\x00\xe2\x01\x26\x00\xaf\x02\x27\x00\x28\x00\x37\x02\xa9\x00\x2a\x00\xde\x00\xb8\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\xb0\x02\x1a\x00\xb9\x00\xba\x00\xaa\x00\xa9\x00\xab\x00\x38\x02\x30\x00\x31\x00\xcd\x00\x8a\x01\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x8b\x01\xd0\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\x16\x02\xe8\x00\x9f\x02\x25\x01\xb1\x00\x26\x01\x38\x01\xa9\x00\xa2\x00\x39\x02\x11\x00\x9e\x00\x17\x02\x27\x01\x28\x01\xbe\x01\xad\x00\xdd\x01\xaf\x00\xa3\x00\xa4\x00\xfd\x00\xd3\x01\x16\x00\xb1\x00\x1c\x00\x1d\x00\x29\x01\x2a\x01\x39\x01\x1e\x00\x31\x01\x1f\x00\x11\x00\x21\x00\xbc\x02\xb2\x00\xb3\x00\x22\x00\x23\x00\x24\x00\xb8\x02\x26\x00\x41\x01\x27\x00\x28\x00\x16\x00\x11\x00\x2a\x00\xba\x02\x2e\x02\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x9e\x00\x7e\x02\xa9\x00\x8f\x02\x90\x02\x16\x00\x7f\x02\x2f\x02\x30\x00\x31\x00\xbb\x02\xc0\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x1a\x00\x6b\x00\x42\x01\x13\x00\x14\x00\x6c\x00\xa2\x00\x39\x02\x6d\x00\x2b\x01\x90\x01\x15\x00\x42\x02\x33\x02\x6e\x00\x6f\x00\x70\x00\xa3\x00\xa4\x00\x71\x00\x72\x00\x97\x02\x91\x01\xc9\x00\xad\x00\x73\x00\x74\x00\x75\x00\xca\x00\xcb\x00\xd4\x00\xcd\x00\xce\x00\x98\x02\x43\x01\xcd\x00\x8a\x01\x61\x02\x27\x02\xb8\x02\xd5\x00\xd0\x00\x62\x02\x28\x02\x8d\x01\xd0\x00\xa9\x00\x1b\x00\x76\x00\x77\x00\x1c\x00\x1d\x00\x78\x00\x79\x00\x7a\x00\x1e\x00\xb9\x02\x1f\x00\x20\x00\x21\x00\x7b\x00\x7c\x00\x7d\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x7e\x00\x27\x00\x28\x00\x7f\x00\x29\x00\x2a\x00\x80\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x81\x00\xcd\x00\x8a\x01\xc9\x01\x82\x00\xd4\x00\x87\x02\x83\x00\x30\x00\x31\x00\x91\x01\xd0\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xaa\x02\x79\x02\x43\x00\x9b\x01\x7b\x02\xa9\x00\x62\x02\xa1\x02\xce\x01\x62\x02\xd4\x00\x9c\x01\x9d\x01\x8f\x00\x9e\x01\x39\x00\x3a\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x1a\x00\x6b\x00\xa8\x02\x84\x02\x85\x02\x6c\x00\x83\x02\x84\x02\x85\x02\xc1\x00\x13\x00\x14\x00\x0d\x01\x0e\x01\x6e\x00\x6f\x00\x70\x00\x87\x02\x15\x00\x71\x00\x72\x00\xc2\x00\xc4\x00\xbd\x00\x9a\x02\x73\x00\x74\x00\x75\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xbe\x00\xa9\x00\xe4\x01\x8d\x02\xd4\x00\xb1\x00\x4b\x01\xa2\x02\x8d\x01\xc3\x00\xd4\x00\x3e\x01\x3f\x01\x13\x00\x14\x00\x8e\x02\xa6\x02\x12\x02\x1c\x00\x1d\x00\xa9\x00\x15\x00\x7d\x02\x1e\x00\x40\x01\x1f\x00\xa9\x00\x21\x00\x24\x02\x13\x02\x81\x02\x22\x00\x23\x00\x24\x00\xa9\x00\x26\x00\x82\x02\x27\x00\x28\x00\x7f\x00\xc9\x01\x2a\x00\xd4\x00\x83\x02\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x13\x01\x14\x01\xac\x00\xad\x00\xae\x00\xaf\x00\x45\x01\x83\x00\x30\x00\x31\x00\x87\x02\xb1\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x1a\x00\xf7\x00\xce\x01\x4c\x01\xd4\x00\xb8\x00\x03\x01\x04\x01\x3e\x01\x3f\x01\x13\x00\x14\x00\x14\x02\x88\x02\x6e\x00\x6f\x00\x70\x00\x89\x02\x15\x00\x71\x00\x72\x00\x40\x01\x15\x01\x16\x01\x15\x02\x73\x00\x74\x00\x75\x00\x8c\x02\xa9\x00\x9b\x00\x13\x00\x14\x00\x3c\x02\x50\x01\x9d\x00\xe2\x01\x18\x02\xd4\x00\x15\x00\x1d\x00\x93\x02\x9e\x00\x0f\x01\x10\x01\x11\x01\x12\x01\x60\x01\xb9\x00\x19\x02\x1c\x00\x1d\x00\x22\x00\x9f\x00\xa9\x00\x1e\x00\x26\x00\x1f\x00\xe4\x01\x21\x00\xd4\x00\x45\x02\xa0\x00\x22\x00\x23\x00\x24\x00\x46\x02\x26\x00\x2f\x00\x27\x00\x28\x00\x7f\x00\x4b\x02\x2a\x00\x32\x02\x33\x02\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x23\x02\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x83\x00\x30\x00\x31\x00\xd2\x01\xd3\x01\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x25\x02\x6b\x00\xce\x01\x5c\x02\xd4\x00\x6c\x00\x03\x01\x04\x01\x6d\x00\xd2\x01\xd9\x01\x93\x01\x26\x02\x4e\x02\x6e\x00\x6f\x00\x70\x00\x27\x02\x23\x02\x71\x00\x72\x00\x0d\x01\x0e\x01\x94\x01\x59\x02\x73\x00\x74\x00\x75\x00\xa9\x00\x0d\x00\x0e\x00\x0f\x00\x5b\x02\x10\x00\x17\x01\x18\x01\x19\x01\x11\x00\x12\x00\x13\x00\x14\x00\x60\x02\x13\x01\x14\x01\x15\x01\x16\x01\x63\x02\x15\x00\x76\x00\x77\x00\x16\x00\x4d\x01\x78\x00\x79\x00\x7a\x00\x7a\x02\x3e\x01\x3f\x01\x13\x00\x14\x00\x7b\x00\x7c\x00\x7d\x00\x7c\x02\xe5\x01\xf2\x01\x15\x00\xb9\x00\x7e\x00\x40\x01\x17\x00\x7f\x00\xfd\x01\xfe\x01\x80\x00\x0f\x02\xc5\x00\x13\x00\x14\x00\x09\x02\x81\x00\x0e\x02\xd4\x01\x11\x02\x82\x00\x15\x00\x1b\x02\x83\x00\xc7\x00\xa9\x00\x1c\x02\x18\x00\x1e\x02\x0d\x00\x1a\x00\xc5\x01\xc6\x01\xd4\x00\x1f\x02\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xb8\x00\x09\x01\x27\x02\x2b\x02\x0a\x01\x2d\x02\x8f\x00\x0b\x01\x47\x00\x48\x00\x49\x00\x4a\x00\x0c\x01\x8f\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\x90\x00\x30\x02\x35\x02\x55\x01\x1b\x00\x5a\x01\x8f\x01\x1c\x00\x1d\x00\xa2\x01\xa9\x00\xa0\x01\x1e\x00\xaf\x01\x1f\x00\x20\x00\x21\x00\xda\x01\xdb\x01\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\xe5\x01\x27\x00\x28\x00\xc9\x00\x29\x00\x2a\x00\xde\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\x0d\x00\x1a\x00\xe0\x00\xeb\x01\xaa\x00\xe1\x00\xab\x00\x30\x00\x31\x00\xe2\x00\x42\x02\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\xe8\x00\xeb\x00\xac\x00\xad\x00\xae\x00\xaf\x00\x2f\x01\xed\x00\xff\xff\x09\x01\x0b\x01\xb1\x00\x43\x02\xb3\x00\x0a\x01\x0c\x01\x4e\x01\x2c\x01\x2d\x01\xff\xff\x31\x01\x3e\x01\x3f\x01\x13\x00\x14\x00\x39\x00\x3a\x00\x96\x00\xc7\x01\x1b\x00\x34\x01\x15\x00\x1c\x00\x1d\x00\x40\x01\x35\x01\xff\xff\x1e\x00\x0d\x00\x1f\x00\x20\x00\x21\x00\x00\x00\xb2\x00\xb3\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x0d\x00\x1a\x00\x00\x00\xee\x01\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x90\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x96\x00\xc7\x01\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x0d\x00\x1a\x00\x00\x00\xf7\x01\x00\x00\x00\x00\x93\x02\x30\x00\x31\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x53\x01\x00\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\x90\x00\x39\x00\x3a\x00\x96\x00\xc7\x01\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x8d\x01\xc6\x01\xd4\x00\x30\x00\x31\x00\x55\x02\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x84\x00\xb8\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x90\x00\x00\x00\x39\x00\x3a\x00\x96\x00\xc7\x01\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\xb4\x01\x30\x00\x31\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x5e\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x90\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x96\x00\xc7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\xa9\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x1a\x00\x91\x00\xf9\x01\xde\x01\x00\x00\xab\x00\x30\x00\x31\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x8f\x00\xb1\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3d\x01\x00\x00\xef\x00\x4c\x00\x7a\x01\x3e\x01\x3f\x01\x13\x00\x14\x00\x39\x00\x3a\x00\x96\x00\x5f\x02\x1b\x00\x00\x00\x15\x00\x1c\x00\x1d\x00\x40\x01\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x53\x01\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\xe7\x01\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x93\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x15\x00\x00\x00\xe2\x00\x16\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x96\x00\xc7\x01\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\xe8\x01\xc1\x01\xc2\x01\x1e\x00\xe9\x01\x1f\x00\x20\x00\x21\x00\x17\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x1a\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x30\x00\x31\x00\xef\x00\xfa\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x3a\x00\x3b\x00\x3c\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x15\x00\x00\x00\xf5\x00\x16\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x96\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\xa9\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x17\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x1a\x00\x2d\x01\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x01\x30\x00\x31\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x42\x00\xb1\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x2f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\xa9\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x1a\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x30\x00\x31\x00\xef\x00\x21\x02\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\xf3\x01\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xbe\x00\x42\x00\x00\x00\x43\x00\x00\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xc5\x00\x13\x00\x14\x00\x00\x00\x00\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x15\x00\x00\x00\x42\x00\xc7\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x1d\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x22\x00\x00\x00\x30\x00\x31\x00\x26\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x8f\x00\x2f\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x7b\x01\x43\x00\x3c\x02\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x1a\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x30\x00\x31\x00\xef\x00\x77\x01\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x93\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x43\x00\x4a\x01\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\xf7\x01\xc1\x01\xc2\x01\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x1a\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x30\x00\x31\x00\xef\x00\x78\x01\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x96\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x1a\x00\x1e\x00\x54\x02\x1f\x00\x20\x00\x21\x00\x00\x00\x17\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x30\x00\x31\x00\xef\x00\x79\x01\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x1a\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x26\x00\x00\x00\x27\x00\x28\x00\x39\x00\x3a\x00\x2a\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x30\x00\x31\x00\xef\x00\xf4\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x1a\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x21\x00\xa2\x00\x52\x01\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x26\x00\x00\x00\x27\x00\x28\x00\xa3\x00\xa4\x00\x2a\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x30\x00\x31\x00\xef\x00\xf8\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x21\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\xa3\x00\xa4\x00\x2a\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x30\x00\x31\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x85\x01\x38\x00\x6b\x01\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x6c\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\x23\x01\x24\x01\x6e\x00\x6f\x00\x70\x00\x45\x01\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x92\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\xf9\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x3a\x00\x3b\x00\x3c\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x8f\x00\x83\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x15\x00\x00\x00\xf7\x00\x16\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x65\x01\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x83\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x82\x01\x3d\x00\x3e\x00\x3f\x00\x40\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x65\x01\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x8f\x00\x6b\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x83\x01\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x8f\x00\x6b\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x7e\x01\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x3a\x00\x3b\x00\x3c\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x65\x01\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x83\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x84\x01\x00\x00\xa6\x00\x40\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x48\x02\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x8f\x00\x6b\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x7f\x01\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x8f\x00\xbc\x01\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\xfa\x00\x00\x00\x6e\x00\x6f\x00\xbd\x01\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x83\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x87\x01\x1d\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x22\x00\x65\x01\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x7f\x00\xbe\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x2f\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x80\x01\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x0c\x02\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\xdc\x00\x00\x00\x93\x00\x0d\x02\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x9c\x02\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x9d\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\xfb\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x46\x01\x3b\x00\xa5\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x47\x01\xef\x00\xfc\x00\x83\x00\x00\x00\x48\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xe6\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xe7\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x7c\x01\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x69\x01\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x8f\x00\x6b\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x81\x01\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x39\x02\x3b\x00\xa5\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x02\x00\x00\x8f\x00\x83\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x7d\x01\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x06\x02\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x07\x02\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x9b\x00\x13\x00\x14\x00\x33\x02\x50\x01\x9d\x00\x93\x00\x0e\x00\x0f\x00\x15\x00\x10\x00\x00\x00\x9e\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x9f\x00\x15\x00\x00\x00\x00\x00\x16\x00\xbe\x01\xad\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x22\x00\x00\x00\xcd\x00\xf9\x01\x26\x00\xc0\x01\xc1\x01\xc2\x01\x7f\x00\x08\x02\x00\x00\xc3\x01\xd0\x00\x17\x00\x00\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\xdc\x00\x00\x00\x93\x00\x99\x02\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x1d\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x22\x00\x73\x00\x74\x00\x75\x00\x26\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x83\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x88\x01\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\xdc\x00\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\xa4\x00\x3b\x00\xa5\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x8b\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x96\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x83\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x86\x01\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x58\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x04\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x23\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x83\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\xe4\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x83\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\xf7\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x0d\x00\x00\x00\x6b\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7f\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x74\x00\x75\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\xbc\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x7f\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\x01\x02\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x02\x00\x00\x9e\x00\x69\x02\x6a\x02\x00\x00\x00\x00\x00\x00\x6b\x02\x00\x00\x00\x00\x6c\x02\x6d\x02\x02\x02\x00\x00\x00\x00\x6e\x02\x6f\x02\x70\x02\x71\x02\x00\x00\x00\x00\x72\x02\x73\x02\x00\x00\x74\x02\x00\x00\x00\x00\x75\x02\x00\x00\x76\x02\x77\x02\x78\x02\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x26\x00\x84\x00\x27\x00\x28\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x00\x00\x00\x00\x94\x01\x3b\x00\xa5\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x9b\x00\x13\x00\x14\x00\x4f\x01\x50\x01\x9d\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x95\x01\x5b\x00\x5c\x00\x96\x01\x97\x01\x00\x00\x98\x01\xa0\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x61\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\x00\x00\x00\x00\x94\x01\x3b\x00\xa5\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x9b\x00\x13\x00\x14\x00\x00\x00\x35\x02\x9d\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x95\x01\x5b\x00\x5c\x00\x00\x00\x1f\x02\x00\x00\x20\x02\xa0\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x61\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\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x93\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\xb0\x02\x5b\x00\x5c\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\xac\x02\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x02\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\xad\x02\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x61\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\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x93\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x9d\x02\x5b\x00\x5c\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x9f\x02\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x4e\x02\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x61\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\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x02\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x50\x02\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x1c\x02\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x61\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\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x01\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\xa0\x01\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\xeb\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x61\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xfe\x00\x9b\x00\x13\x00\x14\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x9e\x00\x9b\x00\x13\x00\x14\x00\x00\x00\x00\x00\xff\x00\x5a\x00\x5b\x00\x5c\x00\x15\x00\x9f\x00\x00\x00\x9e\x00\x00\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x9e\x01\x00\x00\x00\x00\xa0\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x01\x01\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\xfe\x00\x9b\x00\x13\x00\x14\x00\x00\x00\x00\x00\xcf\x01\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x9e\x00\x9b\x00\x13\x00\x14\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x15\x00\x9f\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x01\x00\x00\x00\x00\xa0\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x01\x01\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\xfe\x00\x9b\x00\x13\x00\x14\x00\x00\x00\x00\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x9e\x00\x9b\x00\x13\x00\x14\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x15\x00\x9f\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\xa0\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x01\x01\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\x90\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x90\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x90\x00\x00\x00\x00\x00\x00\x00\xd6\x00\x49\x02\xd8\x00\xd9\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x02\x00\x00\x0a\x02\xd9\x00\xda\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xa2\x01\xa3\x01\xa9\x00\xa4\x01\x3b\x00\xa5\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x93\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x00\x00\x00\x00\xe7\x01\x00\x00\x17\x00\x15\x00\x00\x00\x00\x00\x16\x00\xbe\x01\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\xbf\x01\x00\x00\xc0\x01\xc1\x01\xc2\x01\x00\x00\x00\x00\x00\x00\xc3\x01\xd0\x00\x17\x00\x93\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x00\x00\x00\x00\xe7\x01\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x01\xc1\x01\xc2\x01\x00\x00\xec\x01\x00\x00\x00\x00\x00\x00\x17\x00\x93\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x15\x00\x00\x00\x5a\x01\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x01\xc1\x01\xc2\x01\x00\x00\xf5\x01\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x00\x13\x00\x14\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x46\x01\x3b\x00\xa5\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x5c\x01\x9f\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x5b\x01\x00\x00\x00\x00\xa0\x00\x00\x00\x15\x00\x00\x00\x8f\x00\x16\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xf0\x00\x17\x00\x00\x00\x00\x00\xf2\x01\x00\x00\x00\x00\x00\x00\x00\x00\x47\x01\x00\x00\x00\x00\x00\x00\x00\x00\x48\x01\x00\x00\x00\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x5d\x01\xb3\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\xb8\x01\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x9e\x00\x29\x00\x2a\x00\x00\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\xb9\x01\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x30\x00\x00\x00\x00\x00\x1d\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x25\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x59\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x04\x02\x00\x00\x1c\x00\x1d\x00\x00\x00\xc2\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x21\x00\x00\x00\x00\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x00\x00\x2a\x00\x00\x00\xc2\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x93\x00\x0e\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x12\x00\x13\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x8a\x01\x00\x00\xc0\x01\xc1\x01\xc2\x01\x00\x00\x00\x00\x00\x00\xc3\x01\xd0\x00\x17\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xf0\x00\x00\x00\x00\x00\x8f\x00\xb1\x01\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xf0\x00\x00\x00\x00\x00\x8f\x00\xce\x01\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xf0\x00\x00\x00\x00\x00\x8f\x00\xd5\x01\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xf0\x00\x00\x00\x00\x00\x8f\x00\xf1\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xa2\x01\x4c\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xa2\x01\x19\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xab\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x9a\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x89\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x4b\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x67\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x89\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xa8\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xac\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xad\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xe4\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xa7\x00\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x61\x01\x62\x01\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\x63\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\xa6\x02\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\x63\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x90\x02\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\x63\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x69\x01\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\x63\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x46\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x56\x02\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x6c\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x6d\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x6e\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x6f\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x70\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x71\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x72\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x73\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x74\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x75\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\x76\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xaf\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\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\xe5\x01\x8f\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\xef\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x48\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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 = Happy_Data_Array.array (11, 451) [+ (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)+ ]++happy_n_terms = 140 :: Int+happy_n_nonterms = 104 :: Int++happyReduce_11 = happySpecReduce_1 0# happyReduction_11+happyReduction_11 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn14+ (Id (getID happy_var_1) (locOf happy_var_1)+ )}++happyReduce_12 = happySpecReduce_1 0# happyReduction_12+happyReduction_12 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn14+ (AntiId (getANTI_ID happy_var_1) (locOf happy_var_1)+ )}++happyReduce_13 = happySpecReduce_1 1# happyReduction_13+happyReduction_13 happy_x_1+ = case happyOut14 happy_x_1 of { happy_var_1 -> + happyIn15+ (happy_var_1+ )}++happyReduce_14 = happySpecReduce_1 1# happyReduction_14+happyReduction_14 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn15+ (Id (getNAMED happy_var_1) (locOf happy_var_1)+ )}++happyReduce_15 = happySpecReduce_1 2# happyReduction_15+happyReduction_15 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (let (s, sign, n) = getINT happy_var_1+ in+ IntConst s sign n (locOf happy_var_1)+ )}++happyReduce_16 = happySpecReduce_1 2# happyReduction_16+happyReduction_16 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (let (s, sign, n) = getLONG happy_var_1+ in+ LongIntConst s sign n (locOf happy_var_1)+ )}++happyReduce_17 = happySpecReduce_1 2# happyReduction_17+happyReduction_17 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (let (s, sign, n) = getLONG_LONG happy_var_1+ in+ LongLongIntConst s sign n (locOf happy_var_1)+ )}++happyReduce_18 = happySpecReduce_1 2# happyReduction_18+happyReduction_18 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (let (s, n) = getFLOAT happy_var_1+ in+ FloatConst s n (locOf happy_var_1)+ )}++happyReduce_19 = happySpecReduce_1 2# happyReduction_19+happyReduction_19 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (let (s, n) = getDOUBLE happy_var_1+ in+ DoubleConst s n (locOf happy_var_1)+ )}++happyReduce_20 = happySpecReduce_1 2# happyReduction_20+happyReduction_20 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (let (s, n) = getLONG_DOUBLE happy_var_1+ in+ LongDoubleConst s n (locOf happy_var_1)+ )}++happyReduce_21 = happySpecReduce_1 2# happyReduction_21+happyReduction_21 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (let (s, c) = getCHAR happy_var_1+ in+ CharConst s c (locOf happy_var_1)+ )}++happyReduce_22 = happySpecReduce_1 2# happyReduction_22+happyReduction_22 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiInt (getANTI_INT happy_var_1) (locOf happy_var_1)+ )}++happyReduce_23 = happySpecReduce_1 2# happyReduction_23+happyReduction_23 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiUInt (getANTI_UINT happy_var_1) (locOf happy_var_1)+ )}++happyReduce_24 = happySpecReduce_1 2# happyReduction_24+happyReduction_24 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiLInt (getANTI_LINT happy_var_1) (locOf happy_var_1)+ )}++happyReduce_25 = happySpecReduce_1 2# happyReduction_25+happyReduction_25 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiULInt (getANTI_ULINT happy_var_1) (locOf happy_var_1)+ )}++happyReduce_26 = happySpecReduce_1 2# happyReduction_26+happyReduction_26 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiFloat (getANTI_FLOAT happy_var_1) (locOf happy_var_1)+ )}++happyReduce_27 = happySpecReduce_1 2# happyReduction_27+happyReduction_27 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiDouble (getANTI_DOUBLE happy_var_1) (locOf happy_var_1)+ )}++happyReduce_28 = happySpecReduce_1 2# happyReduction_28+happyReduction_28 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiLongDouble (getANTI_LONG_DOUBLE happy_var_1) (locOf happy_var_1)+ )}++happyReduce_29 = happySpecReduce_1 2# happyReduction_29+happyReduction_29 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiChar (getANTI_CHAR happy_var_1) (locOf happy_var_1)+ )}++happyReduce_30 = happySpecReduce_1 2# happyReduction_30+happyReduction_30 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn16+ (AntiString (getANTI_STRING happy_var_1) (locOf happy_var_1)+ )}++happyReduce_31 = happySpecReduce_1 3# happyReduction_31+happyReduction_31 happy_x_1+ = case happyOut14 happy_x_1 of { happy_var_1 -> + happyIn17+ (Var happy_var_1 (locOf happy_var_1)+ )}++happyReduce_32 = happySpecReduce_1 3# happyReduction_32+happyReduction_32 happy_x_1+ = case happyOut16 happy_x_1 of { happy_var_1 -> + happyIn17+ (Const happy_var_1 (locOf happy_var_1)+ )}++happyReduce_33 = happySpecReduce_1 3# happyReduction_33+happyReduction_33 happy_x_1+ = case happyOut18 happy_x_1 of { happy_var_1 -> + happyIn17+ (let { ss = rev happy_var_1+ ; loc = locOf ss+ ; raw = map (fst . unLoc) ss+ ; s = (concat . intersperse " " . map (snd . unLoc)) ss+ }+ in+ Const (StringConst raw s loc) loc+ )}++happyReduce_34 = happySpecReduce_3 3# happyReduction_34+happyReduction_34 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut36 happy_x_2 of { happy_var_2 -> + happyIn17+ (happy_var_2+ )}++happyReduce_35 = happyMonadReduce 3# 3# happyReduction_35+happyReduction_35 (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 happyOut36 happy_x_2 of { happy_var_2 -> + ( unclosed (happy_var_1 <--> happy_var_2) "(")}}+ ) (\r -> happyReturn (happyIn17 r))++happyReduce_36 = happySpecReduce_3 3# happyReduction_36+happyReduction_36 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut90 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn17+ (let Block items _ = happy_var_2+ in+ StmExpr items (happy_var_1 <--> happy_var_3)+ )}}}++happyReduce_37 = happySpecReduce_1 3# happyReduction_37+happyReduction_37 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn17+ (AntiExp (getANTI_EXP happy_var_1) (locOf happy_var_1)+ )}++happyReduce_38 = happySpecReduce_1 4# happyReduction_38+happyReduction_38 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn18+ (rsingleton (L (getLoc happy_var_1) (getSTRING happy_var_1))+ )}++happyReduce_39 = happySpecReduce_2 4# happyReduction_39+happyReduction_39 happy_x_2+ happy_x_1+ = case happyOut18 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn18+ (rcons (L (getLoc happy_var_2) (getSTRING happy_var_2)) happy_var_1+ )}}++happyReduce_40 = happySpecReduce_1 5# happyReduction_40+happyReduction_40 happy_x_1+ = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn19+ (happy_var_1+ )}++happyReduce_41 = happyMonadReduce 3# 5# happyReduction_41+happyReduction_41 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut19 happy_x_1 of { happy_var_1 -> + ( unclosed (locOf happy_var_1) "[")}+ ) (\r -> happyReturn (happyIn19 r))++happyReduce_42 = happyReduce 4# 5# happyReduction_42+happyReduction_42 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn19+ (Index happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_43 = happyMonadReduce 3# 5# happyReduction_43+happyReduction_43 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + ( unclosed (locOf happy_var_2) "(")}+ ) (\r -> happyReturn (happyIn19 r))++happyReduce_44 = happySpecReduce_3 5# happyReduction_44+happyReduction_44 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn19+ (FnCall happy_var_1 [] (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_45 = happyMonadReduce 4# 5# happyReduction_45+happyReduction_45 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_2 <--> rev happy_var_3) "(")}}+ ) (\r -> happyReturn (happyIn19 r))++happyReduce_46 = happyReduce 4# 5# happyReduction_46+happyReduction_46 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn19+ (FnCall happy_var_1 (rev happy_var_3) (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_47 = happyMonadReduce 4# 5# happyReduction_47+happyReduction_47 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut20 happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_2 <--> happy_var_3) "<<<")}}+ ) (\r -> happyReturn (happyIn19 r))++happyReduce_48 = happyReduce 6# 5# happyReduction_48+happyReduction_48 (happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + happyIn19+ (CudaCall happy_var_1 happy_var_3 [] (happy_var_1 <--> happy_var_6)+ ) `HappyStk` happyRest}}}++happyReduce_49 = happyMonadReduce 7# 5# happyReduction_49+happyReduction_49 (happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_5 of { happy_var_5 -> + case happyOut21 happy_x_6 of { happy_var_6 -> + ( unclosed (happy_var_5 <--> rev happy_var_6) "(")}}+ ) (\r -> happyReturn (happyIn19 r))++happyReduce_50 = happyReduce 7# 5# happyReduction_50+happyReduction_50 (happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut20 happy_x_3 of { happy_var_3 -> + case happyOut21 happy_x_6 of { happy_var_6 -> + case happyOutTok happy_x_7 of { happy_var_7 -> + happyIn19+ (CudaCall happy_var_1 happy_var_3 (rev happy_var_6) (happy_var_1 <--> happy_var_7)+ ) `HappyStk` happyRest}}}}++happyReduce_51 = happySpecReduce_3 5# happyReduction_51+happyReduction_51 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_3 of { happy_var_3 -> + happyIn19+ (Member happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_52 = happySpecReduce_3 5# happyReduction_52+happyReduction_52 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_3 of { happy_var_3 -> + happyIn19+ (PtrMember happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_53 = happySpecReduce_2 5# happyReduction_53+happyReduction_53 happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn19+ (PostInc happy_var_1 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_54 = happySpecReduce_2 5# happyReduction_54+happyReduction_54 happy_x_2+ happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn19+ (PostDec happy_var_1 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_55 = happyReduce 6# 5# happyReduction_55+happyReduction_55 (happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut79 happy_x_2 of { happy_var_2 -> + case happyOut84 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + happyIn19+ (CompoundLit (happy_var_2 :: Type) (rev happy_var_5) (happy_var_1 <--> happy_var_6)+ ) `HappyStk` happyRest}}}}++happyReduce_56 = happyReduce 7# 5# happyReduction_56+happyReduction_56 (happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut79 happy_x_2 of { happy_var_2 -> + case happyOut84 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_7 of { happy_var_7 -> + happyIn19+ (CompoundLit happy_var_2 (rev happy_var_5) (happy_var_1 <--> happy_var_7)+ ) `HappyStk` happyRest}}}}++happyReduce_57 = happyReduce 6# 5# happyReduction_57+happyReduction_57 (happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + case happyOut77 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + happyIn19+ (BuiltinVaArg happy_var_3 happy_var_5 (happy_var_1 <--> happy_var_6)+ ) `HappyStk` happyRest}}}}++happyReduce_58 = happyMonadReduce 1# 6# happyReduction_58+happyReduction_58 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut21 happy_x_1 of { happy_var_1 -> + (do { let args = rev happy_var_1+ ; when (length args < 2 || length args > 4) $+ badExecutionContext (getLoc args) args+ ; return $+ case args of+ [gridDim, blockDim] ->+ ExeConfig gridDim blockDim+ Nothing Nothing+ (locOf args)+ [gridDim, blockDim, sharedSize] ->+ ExeConfig gridDim blockDim+ (Just sharedSize) Nothing+ (locOf args)+ [gridDim, blockDim, sharedSize, exeStream] ->+ ExeConfig gridDim blockDim+ (Just sharedSize) (Just exeStream)+ (locOf args)+ })}+ ) (\r -> happyReturn (happyIn20 r))++happyReduce_59 = happySpecReduce_1 7# happyReduction_59+happyReduction_59 happy_x_1+ = case happyOut35 happy_x_1 of { happy_var_1 -> + happyIn21+ (rsingleton happy_var_1+ )}++happyReduce_60 = happySpecReduce_1 7# happyReduction_60+happyReduction_60 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn21+ (rsingleton (AntiArgs (getANTI_ARGS happy_var_1) (locOf happy_var_1))+ )}++happyReduce_61 = happySpecReduce_3 7# happyReduction_61+happyReduction_61 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut21 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn21+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_62 = happySpecReduce_3 7# happyReduction_62+happyReduction_62 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut21 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn21+ (rcons (AntiArgs (getANTI_ARGS happy_var_3) (locOf happy_var_3)) happy_var_1+ )}}++happyReduce_63 = happySpecReduce_1 8# happyReduction_63+happyReduction_63 happy_x_1+ = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn22+ (happy_var_1+ )}++happyReduce_64 = happySpecReduce_2 8# happyReduction_64+happyReduction_64 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn22+ (PreInc happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_65 = happySpecReduce_2 8# happyReduction_65+happyReduction_65 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn22+ (PreDec happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_66 = happySpecReduce_2 8# happyReduction_66+happyReduction_66 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22+ (UnOp AddrOf happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_67 = happySpecReduce_2 8# happyReduction_67+happyReduction_67 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22+ (UnOp Deref happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_68 = happySpecReduce_2 8# happyReduction_68+happyReduction_68 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22+ (UnOp Positive happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_69 = happySpecReduce_2 8# happyReduction_69+happyReduction_69 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22+ (UnOp Negate happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_70 = happySpecReduce_2 8# happyReduction_70+happyReduction_70 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22+ (UnOp Not happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_71 = happySpecReduce_2 8# happyReduction_71+happyReduction_71 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_2 of { happy_var_2 -> + happyIn22+ (UnOp Lnot happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_72 = happySpecReduce_2 8# happyReduction_72+happyReduction_72 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_2 of { happy_var_2 -> + happyIn22+ (SizeofExp happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_73 = happyReduce 4# 8# happyReduction_73+happyReduction_73 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut79 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn22+ (SizeofType happy_var_3 (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_74 = happyMonadReduce 4# 8# happyReduction_74+happyReduction_74 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut79 happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_2 <--> happy_var_3) "(")}}+ ) (\r -> happyReturn (happyIn22 r))++happyReduce_75 = happySpecReduce_1 9# happyReduction_75+happyReduction_75 happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn23+ (happy_var_1+ )}++happyReduce_76 = happyReduce 4# 9# happyReduction_76+happyReduction_76 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut79 happy_x_2 of { happy_var_2 -> + case happyOut23 happy_x_4 of { happy_var_4 -> + happyIn23+ (Cast happy_var_2 happy_var_4 (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_77 = happyMonadReduce 3# 9# happyReduction_77+happyReduction_77 (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 -> + ( unclosed (happy_var_1 <--> happy_var_2) "(")}}+ ) (\r -> happyReturn (happyIn23 r))++happyReduce_78 = happySpecReduce_1 10# happyReduction_78+happyReduction_78 happy_x_1+ = case happyOut23 happy_x_1 of { happy_var_1 -> + happyIn24+ (happy_var_1+ )}++happyReduce_79 = happySpecReduce_3 10# happyReduction_79+happyReduction_79 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_3 of { happy_var_3 -> + happyIn24+ (BinOp Mul happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_80 = happySpecReduce_3 10# happyReduction_80+happyReduction_80 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_3 of { happy_var_3 -> + happyIn24+ (BinOp Div happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_81 = happySpecReduce_3 10# happyReduction_81+happyReduction_81 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_3 of { happy_var_3 -> + happyIn24+ (BinOp Mod happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_82 = happySpecReduce_1 11# happyReduction_82+happyReduction_82 happy_x_1+ = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn25+ (happy_var_1+ )}++happyReduce_83 = happySpecReduce_3 11# happyReduction_83+happyReduction_83 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn25+ (BinOp Add happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_84 = happySpecReduce_3 11# happyReduction_84+happyReduction_84 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn25+ (BinOp Sub happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_85 = happySpecReduce_1 12# happyReduction_85+happyReduction_85 happy_x_1+ = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn26+ (happy_var_1+ )}++happyReduce_86 = happySpecReduce_3 12# happyReduction_86+happyReduction_86 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn26+ (BinOp Lsh happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_87 = happySpecReduce_3 12# happyReduction_87+happyReduction_87 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn26+ (BinOp Rsh happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_88 = happySpecReduce_1 13# happyReduction_88+happyReduction_88 happy_x_1+ = case happyOut26 happy_x_1 of { happy_var_1 -> + happyIn27+ (happy_var_1+ )}++happyReduce_89 = happySpecReduce_3 13# happyReduction_89+happyReduction_89 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut27 happy_x_1 of { happy_var_1 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + happyIn27+ (BinOp Lt happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_90 = happySpecReduce_3 13# happyReduction_90+happyReduction_90 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut27 happy_x_1 of { happy_var_1 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + happyIn27+ (BinOp Gt happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_91 = happySpecReduce_3 13# happyReduction_91+happyReduction_91 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut27 happy_x_1 of { happy_var_1 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + happyIn27+ (BinOp Le happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_92 = happySpecReduce_3 13# happyReduction_92+happyReduction_92 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut27 happy_x_1 of { happy_var_1 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + happyIn27+ (BinOp Ge happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_93 = happySpecReduce_1 14# happyReduction_93+happyReduction_93 happy_x_1+ = case happyOut27 happy_x_1 of { happy_var_1 -> + happyIn28+ (happy_var_1+ )}++happyReduce_94 = happySpecReduce_3 14# happyReduction_94+happyReduction_94 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut28 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_3 of { happy_var_3 -> + happyIn28+ (BinOp Eq happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_95 = happySpecReduce_3 14# happyReduction_95+happyReduction_95 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut28 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_3 of { happy_var_3 -> + happyIn28+ (BinOp Ne happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_96 = happySpecReduce_1 15# happyReduction_96+happyReduction_96 happy_x_1+ = case happyOut28 happy_x_1 of { happy_var_1 -> + happyIn29+ (happy_var_1+ )}++happyReduce_97 = happySpecReduce_3 15# happyReduction_97+happyReduction_97 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut29 happy_x_1 of { happy_var_1 -> + case happyOut28 happy_x_3 of { happy_var_3 -> + happyIn29+ (BinOp And happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_98 = happySpecReduce_1 16# happyReduction_98+happyReduction_98 happy_x_1+ = case happyOut29 happy_x_1 of { happy_var_1 -> + happyIn30+ (happy_var_1+ )}++happyReduce_99 = happySpecReduce_3 16# happyReduction_99+happyReduction_99 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut30 happy_x_1 of { happy_var_1 -> + case happyOut29 happy_x_3 of { happy_var_3 -> + happyIn30+ (BinOp Xor happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_100 = happySpecReduce_1 17# happyReduction_100+happyReduction_100 happy_x_1+ = case happyOut30 happy_x_1 of { happy_var_1 -> + happyIn31+ (happy_var_1+ )}++happyReduce_101 = happySpecReduce_3 17# happyReduction_101+happyReduction_101 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut31 happy_x_1 of { happy_var_1 -> + case happyOut30 happy_x_3 of { happy_var_3 -> + happyIn31+ (BinOp Or happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_102 = happySpecReduce_1 18# happyReduction_102+happyReduction_102 happy_x_1+ = case happyOut31 happy_x_1 of { happy_var_1 -> + happyIn32+ (happy_var_1+ )}++happyReduce_103 = happySpecReduce_3 18# happyReduction_103+happyReduction_103 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut32 happy_x_1 of { happy_var_1 -> + case happyOut31 happy_x_3 of { happy_var_3 -> + happyIn32+ (BinOp Land happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_104 = happySpecReduce_1 19# happyReduction_104+happyReduction_104 happy_x_1+ = case happyOut32 happy_x_1 of { happy_var_1 -> + happyIn33+ (happy_var_1+ )}++happyReduce_105 = happySpecReduce_3 19# happyReduction_105+happyReduction_105 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut33 happy_x_1 of { happy_var_1 -> + case happyOut32 happy_x_3 of { happy_var_3 -> + happyIn33+ (BinOp Lor happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_106 = happySpecReduce_1 20# happyReduction_106+happyReduction_106 happy_x_1+ = case happyOut33 happy_x_1 of { happy_var_1 -> + happyIn34+ (happy_var_1+ )}++happyReduce_107 = happyReduce 5# 20# happyReduction_107+happyReduction_107 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut33 happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + case happyOut34 happy_x_5 of { happy_var_5 -> + happyIn34+ (Cond happy_var_1 happy_var_3 happy_var_5 (happy_var_1 <--> happy_var_5)+ ) `HappyStk` happyRest}}}++happyReduce_108 = happySpecReduce_1 21# happyReduction_108+happyReduction_108 happy_x_1+ = case happyOut34 happy_x_1 of { happy_var_1 -> + happyIn35+ (happy_var_1+ )}++happyReduce_109 = happySpecReduce_3 21# happyReduction_109+happyReduction_109 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 JustAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_110 = happySpecReduce_3 21# happyReduction_110+happyReduction_110 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 MulAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_111 = happySpecReduce_3 21# happyReduction_111+happyReduction_111 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 DivAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_112 = happySpecReduce_3 21# happyReduction_112+happyReduction_112 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 ModAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_113 = happySpecReduce_3 21# happyReduction_113+happyReduction_113 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 AddAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_114 = happySpecReduce_3 21# happyReduction_114+happyReduction_114 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 SubAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_115 = happySpecReduce_3 21# happyReduction_115+happyReduction_115 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 LshAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_116 = happySpecReduce_3 21# happyReduction_116+happyReduction_116 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 RshAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_117 = happySpecReduce_3 21# happyReduction_117+happyReduction_117 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 AndAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_118 = happySpecReduce_3 21# happyReduction_118+happyReduction_118 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 XorAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_119 = happySpecReduce_3 21# happyReduction_119+happyReduction_119 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn35+ (Assign happy_var_1 OrAssign happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_120 = happySpecReduce_1 22# happyReduction_120+happyReduction_120 happy_x_1+ = case happyOut35 happy_x_1 of { happy_var_1 -> + happyIn36+ (happy_var_1+ )}++happyReduce_121 = happySpecReduce_3 22# happyReduction_121+happyReduction_121 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut36 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn36+ (Seq happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_122 = happySpecReduce_0 23# happyReduction_122+happyReduction_122 = happyIn37+ (Nothing+ )++happyReduce_123 = happySpecReduce_1 23# happyReduction_123+happyReduction_123 happy_x_1+ = case happyOut36 happy_x_1 of { happy_var_1 -> + happyIn37+ (Just happy_var_1+ )}++happyReduce_124 = happySpecReduce_1 24# happyReduction_124+happyReduction_124 happy_x_1+ = case happyOut34 happy_x_1 of { happy_var_1 -> + happyIn38+ (happy_var_1+ )}++happyReduce_125 = happySpecReduce_2 25# happyReduction_125+happyReduction_125 happy_x_2+ happy_x_1+ = case happyOut40 happy_x_1 of { happy_var_1 -> + happyIn39+ (happy_var_1+ )}++happyReduce_126 = happyMonadReduce 1# 26# happyReduction_126+happyReduction_126 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + ( do{ let (dspec, decl) = happy_var_1+ ; checkInitGroup dspec decl [] []+ })}+ ) (\r -> happyReturn (happyIn40 r))++happyReduce_127 = happyMonadReduce 2# 26# happyReduction_127+happyReduction_127 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_2 of { happy_var_2 -> + ( do{ let (dspec, decl) = happy_var_1+ ; checkInitGroup dspec decl happy_var_2 []+ })}}+ ) (\r -> happyReturn (happyIn40 r))++happyReduce_128 = happyMonadReduce 2# 26# happyReduction_128+happyReduction_128 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_2 of { happy_var_2 -> + ( do{ let (dspec, decl) = happy_var_1+ ; let inits = rev happy_var_2+ ; checkInitGroup dspec decl [] (rev happy_var_2)+ })}}+ ) (\r -> happyReturn (happyIn40 r))++happyReduce_129 = happyMonadReduce 3# 26# happyReduction_129+happyReduction_129 (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 happyOut104 happy_x_2 of { happy_var_2 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + ( do{ let (dspec, decl) = happy_var_1+ ; checkInitGroup dspec decl happy_var_2 (rev happy_var_3)+ })}}}+ ) (\r -> happyReturn (happyIn40 r))++happyReduce_130 = happyMonadReduce 2# 26# happyReduction_130+happyReduction_130 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut41 happy_x_1 of { happy_var_1 -> + ( do{ let (_, decl) = happy_var_1+ ; expected (locOf decl) ["';'"]+ })}+ ) (\r -> happyReturn (happyIn40 r))++happyReduce_131 = happySpecReduce_1 26# happyReduction_131+happyReduction_131 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn40+ (AntiDecl (getANTI_DECL happy_var_1) (locOf happy_var_1)+ )}++happyReduce_132 = happySpecReduce_1 27# happyReduction_132+happyReduction_132 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn41+ (let { v = getANTI_TYPE happy_var_1+ ; loc = locOf happy_var_1+ }+ in+ (AntiTypeDeclSpec [] [] v loc, AntiTypeDecl v loc)+ )}++happyReduce_133 = happySpecReduce_2 27# happyReduction_133+happyReduction_133 happy_x_2+ happy_x_1+ = case happyOut45 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn41+ (let { storage = mkStorage happy_var_1+ ; typeQuals = mkTypeQuals happy_var_1+ ; v = getANTI_TYPE happy_var_2+ ; loc = happy_var_1 <--> happy_var_2+ }+ in+ (AntiTypeDeclSpec storage typeQuals v loc, AntiTypeDecl v loc)+ )}}++happyReduce_134 = happySpecReduce_1 27# happyReduction_134+happyReduction_134 happy_x_1+ = case happyOut42 happy_x_1 of { happy_var_1 -> + happyIn41+ (happy_var_1+ )}++happyReduce_135 = happySpecReduce_1 27# happyReduction_135+happyReduction_135 happy_x_1+ = case happyOut43 happy_x_1 of { happy_var_1 -> + happyIn41+ (happy_var_1+ )}++happyReduce_136 = happySpecReduce_1 28# happyReduction_136+happyReduction_136 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn42+ (let dspec = AntiDeclSpec (getANTI_SPEC happy_var_1) (locOf happy_var_1)+ in+ (dspec, DeclRoot (locOf happy_var_1))+ )}++happyReduce_137 = happyMonadReduce 1# 28# happyReduction_137+happyReduction_137 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut45 happy_x_1 of { happy_var_1 -> + ( do{ dspec <- mkDeclSpec happy_var_1+ ; return (dspec, DeclRoot (locOf happy_var_1))+ })}+ ) (\r -> happyReturn (happyIn42 r))++happyReduce_138 = happyMonadReduce 1# 28# happyReduction_138+happyReduction_138 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut50 happy_x_1 of { happy_var_1 -> + ( do{ dspec <- mkDeclSpec [happy_var_1]+ ; return (dspec, DeclRoot (locOf happy_var_1) )+ })}+ ) (\r -> happyReturn (happyIn42 r))++happyReduce_139 = happyMonadReduce 2# 28# happyReduction_139+happyReduction_139 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut50 happy_x_1 of { happy_var_1 -> + case happyOut44 happy_x_2 of { happy_var_2 -> + ( do{ dspec <- mkDeclSpec (happy_var_1 : happy_var_2)+ ; return (dspec, DeclRoot (happy_var_1 <--> happy_var_2))+ })}}+ ) (\r -> happyReturn (happyIn42 r))++happyReduce_140 = happyMonadReduce 2# 28# happyReduction_140+happyReduction_140 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut45 happy_x_1 of { happy_var_1 -> + case happyOut50 happy_x_2 of { happy_var_2 -> + ( do{ dspec <- mkDeclSpec (happy_var_1 ++ [happy_var_2])+ ; return $(dspec, DeclRoot (happy_var_1 <--> happy_var_2))+ })}}+ ) (\r -> happyReturn (happyIn42 r))++happyReduce_141 = happyMonadReduce 3# 28# happyReduction_141+happyReduction_141 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut45 happy_x_1 of { happy_var_1 -> + case happyOut50 happy_x_2 of { happy_var_2 -> + case happyOut44 happy_x_3 of { happy_var_3 -> + ( do{ dspec <- mkDeclSpec (happy_var_1 ++ happy_var_2 : happy_var_3)+ ; return (dspec, DeclRoot (happy_var_1 <--> happy_var_3))+ })}}}+ ) (\r -> happyReturn (happyIn42 r))++happyReduce_142 = happyMonadReduce 1# 29# happyReduction_142+happyReduction_142 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + ( do{ dspec <- mkDeclSpec [happy_var_1]+ ; return (dspec, DeclRoot (locOf happy_var_1))+ })}+ ) (\r -> happyReturn (happyIn43 r))++happyReduce_143 = happyMonadReduce 2# 29# happyReduction_143+happyReduction_143 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOut45 happy_x_2 of { happy_var_2 -> + ( do{ dspec <- mkDeclSpec (happy_var_1 : happy_var_2)+ ; return (dspec, DeclRoot (happy_var_1 <--> happy_var_2))+ })}}+ ) (\r -> happyReturn (happyIn43 r))++happyReduce_144 = happyMonadReduce 2# 29# happyReduction_144+happyReduction_144 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut45 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_2 of { happy_var_2 -> + ( do{ dspec <- mkDeclSpec (happy_var_1 ++ [happy_var_2])+ ; return (dspec, DeclRoot (happy_var_1 <--> happy_var_2))+ })}}+ ) (\r -> happyReturn (happyIn43 r))++happyReduce_145 = happyMonadReduce 3# 29# happyReduction_145+happyReduction_145 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut45 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_2 of { happy_var_2 -> + case happyOut45 happy_x_3 of { happy_var_3 -> + ( do{ dspec <- mkDeclSpec (happy_var_1 ++ happy_var_2 : happy_var_3)+ ; return (dspec, DeclRoot (happy_var_1 <--> happy_var_3))+ })}}}+ ) (\r -> happyReturn (happyIn43 r))++happyReduce_146 = happySpecReduce_1 30# happyReduction_146+happyReduction_146 happy_x_1+ = case happyOut49 happy_x_1 of { happy_var_1 -> + happyIn44+ ([happy_var_1]+ )}++happyReduce_147 = happySpecReduce_2 30# happyReduction_147+happyReduction_147 happy_x_2+ happy_x_1+ = case happyOut49 happy_x_1 of { happy_var_1 -> + case happyOut44 happy_x_2 of { happy_var_2 -> + happyIn44+ (happy_var_1 : happy_var_2+ )}}++happyReduce_148 = happySpecReduce_1 30# happyReduction_148+happyReduction_148 happy_x_1+ = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn44+ ([happy_var_1]+ )}++happyReduce_149 = happySpecReduce_2 30# happyReduction_149+happyReduction_149 happy_x_2+ happy_x_1+ = case happyOut50 happy_x_1 of { happy_var_1 -> + case happyOut44 happy_x_2 of { happy_var_2 -> + happyIn44+ (happy_var_1 : happy_var_2+ )}}++happyReduce_150 = happySpecReduce_1 30# happyReduction_150+happyReduction_150 happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + happyIn44+ ([happy_var_1]+ )}++happyReduce_151 = happySpecReduce_2 30# happyReduction_151+happyReduction_151 happy_x_2+ happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut44 happy_x_2 of { happy_var_2 -> + happyIn44+ (happy_var_1 : happy_var_2+ )}}++happyReduce_152 = happySpecReduce_1 31# happyReduction_152+happyReduction_152 happy_x_1+ = case happyOut49 happy_x_1 of { happy_var_1 -> + happyIn45+ ([happy_var_1]+ )}++happyReduce_153 = happySpecReduce_2 31# happyReduction_153+happyReduction_153 happy_x_2+ happy_x_1+ = case happyOut49 happy_x_1 of { happy_var_1 -> + case happyOut45 happy_x_2 of { happy_var_2 -> + happyIn45+ (happy_var_1 : happy_var_2+ )}}++happyReduce_154 = happySpecReduce_1 31# happyReduction_154+happyReduction_154 happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + happyIn45+ ([happy_var_1]+ )}++happyReduce_155 = happySpecReduce_2 31# happyReduction_155+happyReduction_155 happy_x_2+ happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut45 happy_x_2 of { happy_var_2 -> + happyIn45+ (happy_var_1 : happy_var_2+ )}}++happyReduce_156 = happySpecReduce_1 32# happyReduction_156+happyReduction_156 happy_x_1+ = case happyOut48 happy_x_1 of { happy_var_1 -> + happyIn46+ (rsingleton happy_var_1+ )}++happyReduce_157 = happySpecReduce_3 32# happyReduction_157+happyReduction_157 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut46 happy_x_1 of { happy_var_1 -> + case happyOut48 happy_x_3 of { happy_var_3 -> + happyIn46+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_158 = happySpecReduce_0 33# happyReduction_158+happyReduction_158 = happyIn47+ (Nothing+ )++happyReduce_159 = happyReduce 4# 33# happyReduction_159+happyReduction_159 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn47+ (Just ((fst . getSTRING) happy_var_3)+ ) `HappyStk` happyRest}++happyReduce_160 = happySpecReduce_2 34# happyReduction_160+happyReduction_160 happy_x_2+ happy_x_1+ = case happyOut67 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_2 of { happy_var_2 -> + happyIn48+ (let { (ident, declToDecl) = happy_var_1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Init ident decl happy_var_2 Nothing [] (ident <--> decl)+ )}}++happyReduce_161 = happySpecReduce_3 34# happyReduction_161+happyReduction_161 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut67 happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_2 of { happy_var_2 -> + case happyOut47 happy_x_3 of { happy_var_3 -> + happyIn48+ (let { (ident, declToDecl) = happy_var_1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Init ident decl happy_var_3 Nothing happy_var_2 (ident <--> decl)+ )}}}++happyReduce_162 = happyReduce 4# 34# happyReduction_162+happyReduction_162 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut67 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_2 of { happy_var_2 -> + case happyOut83 happy_x_4 of { happy_var_4 -> + happyIn48+ (let { (ident, declToDecl) = happy_var_1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Init ident decl happy_var_2 (Just happy_var_4) [] (ident <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_163 = happyReduce 5# 34# 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)+ = case happyOut67 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_2 of { happy_var_2 -> + case happyOut104 happy_x_4 of { happy_var_4 -> + case happyOut83 happy_x_5 of { happy_var_5 -> + happyIn48+ (let { (ident, declToDecl) = happy_var_1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Init ident decl happy_var_2 (Just happy_var_5) happy_var_4 (ident <--> happy_var_5)+ ) `HappyStk` happyRest}}}}++happyReduce_164 = happyMonadReduce 2# 34# happyReduction_164+happyReduction_164 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut67 happy_x_1 of { happy_var_1 -> + ( do{ let (ident, declToDecl) = happy_var_1+ ; let decl = declToDecl (declRoot ident)+ ; expected (locOf decl) ["'='"]+ })}+ ) (\r -> happyReturn (happyIn48 r))++happyReduce_165 = happySpecReduce_1 35# happyReduction_165+happyReduction_165 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn49+ (TSauto (locOf happy_var_1)+ )}++happyReduce_166 = happySpecReduce_1 35# happyReduction_166+happyReduction_166 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn49+ (TSregister (locOf happy_var_1)+ )}++happyReduce_167 = happySpecReduce_1 35# happyReduction_167+happyReduction_167 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn49+ (TSstatic (locOf happy_var_1)+ )}++happyReduce_168 = happySpecReduce_1 35# happyReduction_168+happyReduction_168 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn49+ (TSextern (locOf happy_var_1)+ )}++happyReduce_169 = happySpecReduce_2 35# happyReduction_169+happyReduction_169 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn49+ (TSexternL ((snd . getSTRING) happy_var_2) (locOf happy_var_1)+ )}}++happyReduce_170 = happySpecReduce_1 35# happyReduction_170+happyReduction_170 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn49+ (TStypedef (locOf happy_var_1)+ )}++happyReduce_171 = happySpecReduce_1 36# happyReduction_171+happyReduction_171 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSvoid (locOf happy_var_1)+ )}++happyReduce_172 = happySpecReduce_1 36# happyReduction_172+happyReduction_172 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSchar (locOf happy_var_1)+ )}++happyReduce_173 = happySpecReduce_1 36# happyReduction_173+happyReduction_173 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSshort (locOf happy_var_1)+ )}++happyReduce_174 = happySpecReduce_1 36# happyReduction_174+happyReduction_174 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSint (locOf happy_var_1)+ )}++happyReduce_175 = happySpecReduce_1 36# happyReduction_175+happyReduction_175 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSlong (locOf happy_var_1)+ )}++happyReduce_176 = happySpecReduce_1 36# happyReduction_176+happyReduction_176 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSfloat (locOf happy_var_1)+ )}++happyReduce_177 = happySpecReduce_1 36# happyReduction_177+happyReduction_177 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSdouble (locOf happy_var_1)+ )}++happyReduce_178 = happySpecReduce_1 36# happyReduction_178+happyReduction_178 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSsigned (locOf happy_var_1)+ )}++happyReduce_179 = happySpecReduce_1 36# happyReduction_179+happyReduction_179 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSunsigned (locOf happy_var_1)+ )}++happyReduce_180 = happySpecReduce_1 36# happyReduction_180+happyReduction_180 happy_x_1+ = case happyOut51 happy_x_1 of { happy_var_1 -> + happyIn50+ (happy_var_1+ )}++happyReduce_181 = happySpecReduce_1 36# happyReduction_181+happyReduction_181 happy_x_1+ = case happyOut59 happy_x_1 of { happy_var_1 -> + happyIn50+ (happy_var_1+ )}++happyReduce_182 = happySpecReduce_1 36# happyReduction_182+happyReduction_182 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn50+ (TSva_list (locOf happy_var_1)+ )}++happyReduce_183 = happySpecReduce_2 37# happyReduction_183+happyReduction_183 happy_x_2+ happy_x_1+ = case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_2 of { happy_var_2 -> + happyIn51+ ((unLoc happy_var_1) (Just happy_var_2) Nothing [] (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_184 = happySpecReduce_3 37# happyReduction_184+happyReduction_184 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_2 of { happy_var_2 -> + case happyOut15 happy_x_3 of { happy_var_3 -> + happyIn51+ ((unLoc happy_var_1) (Just happy_var_3) Nothing happy_var_2 (happy_var_1 <--> happy_var_3)+ )}}}++happyReduce_185 = happyReduce 4# 37# happyReduction_185+happyReduction_185 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn51+ ((unLoc happy_var_1) Nothing (Just (rev happy_var_3)) [] (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_186 = happyMonadReduce 4# 37# happyReduction_186+happyReduction_186 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_1 <--> rev happy_var_3) "{")}}+ ) (\r -> happyReturn (happyIn51 r))++happyReduce_187 = happyReduce 5# 37# happyReduction_187+happyReduction_187 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_2 of { happy_var_2 -> + case happyOut53 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + happyIn51+ ((unLoc happy_var_1) (Just happy_var_2) (Just (rev happy_var_4)) [] (happy_var_1 <--> happy_var_5)+ ) `HappyStk` happyRest}}}}++happyReduce_188 = happyMonadReduce 5# 37# happyReduction_188+happyReduction_188 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_4 of { happy_var_4 -> + ( unclosed (happy_var_1 <--> rev happy_var_4) "{")}}+ ) (\r -> happyReturn (happyIn51 r))++happyReduce_189 = happyReduce 6# 37# happyReduction_189+happyReduction_189 (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 happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_2 of { happy_var_2 -> + case happyOut15 happy_x_3 of { happy_var_3 -> + case happyOut53 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + happyIn51+ ((unLoc happy_var_1) (Just happy_var_3) (Just (rev happy_var_5)) happy_var_2 (happy_var_1 <--> happy_var_6)+ ) `HappyStk` happyRest}}}}}++happyReduce_190 = happyMonadReduce 6# 37# happyReduction_190+happyReduction_190 (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 happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_5 of { happy_var_5 -> + ( unclosed (happy_var_1 <--> rev happy_var_5) "{")}}+ ) (\r -> happyReturn (happyIn51 r))++happyReduce_191 = happySpecReduce_1 38# happyReduction_191+happyReduction_191 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn52+ (L (getLoc happy_var_1) TSstruct+ )}++happyReduce_192 = happySpecReduce_1 38# happyReduction_192+happyReduction_192 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn52+ (L (getLoc happy_var_1) TSunion+ )}++happyReduce_193 = happySpecReduce_1 39# happyReduction_193+happyReduction_193 happy_x_1+ = case happyOut54 happy_x_1 of { happy_var_1 -> + happyIn53+ (rsingleton happy_var_1+ )}++happyReduce_194 = happySpecReduce_1 39# happyReduction_194+happyReduction_194 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn53+ (rsingleton (AntiSdecls (getANTI_SDECLS happy_var_1) (locOf happy_var_1))+ )}++happyReduce_195 = happySpecReduce_2 39# happyReduction_195+happyReduction_195 happy_x_2+ happy_x_1+ = case happyOut53 happy_x_1 of { happy_var_1 -> + case happyOut54 happy_x_2 of { happy_var_2 -> + happyIn53+ (rcons happy_var_2 happy_var_1+ )}}++happyReduce_196 = happySpecReduce_2 39# happyReduction_196+happyReduction_196 happy_x_2+ happy_x_1+ = case happyOut53 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn53+ (rcons (AntiSdecls (getANTI_SDECLS happy_var_2) (locOf happy_var_2)) happy_var_1+ )}}++happyReduce_197 = happySpecReduce_3 40# happyReduction_197+happyReduction_197 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut57 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn54+ (let dspec = AntiDeclSpec (getANTI_SPEC happy_var_1) (locOf happy_var_1)+ in+ FieldGroup dspec (rev happy_var_2) (happy_var_1 <--> happy_var_3)+ )}}}++happyReduce_198 = happyMonadReduce 3# 40# happyReduction_198+happyReduction_198 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut55 happy_x_1 of { happy_var_1 -> + case happyOut57 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( do{ dspec <- mkDeclSpec happy_var_1+ ; return $ FieldGroup dspec (rev happy_var_2) (happy_var_1 <--> happy_var_3)+ })}}}+ ) (\r -> happyReturn (happyIn54 r))++happyReduce_199 = happyMonadReduce 3# 40# happyReduction_199+happyReduction_199 (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 happyOut15 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + ( do{ let v = getANTI_TYPE happy_var_1+ ; let dspec = AntiTypeDeclSpec [] [] v (locOf happy_var_1)+ ; let decl = AntiTypeDecl v (locOf happy_var_1)+ ; let field = Field (Just happy_var_2) (Just decl) Nothing (happy_var_1 <--> happy_var_2)+ ; return $ FieldGroup dspec [field] (happy_var_1 <--> happy_var_3)+ })}}}+ ) (\r -> happyReturn (happyIn54 r))++happyReduce_200 = happySpecReduce_1 40# happyReduction_200+happyReduction_200 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn54+ (AntiSdecl (getANTI_SDECL happy_var_1) (locOf happy_var_1)+ )}++happyReduce_201 = happySpecReduce_2 41# happyReduction_201+happyReduction_201 happy_x_2+ happy_x_1+ = case happyOut50 happy_x_1 of { happy_var_1 -> + case happyOut56 happy_x_2 of { happy_var_2 -> + happyIn55+ (happy_var_1 : happy_var_2+ )}}++happyReduce_202 = happySpecReduce_3 41# happyReduction_202+happyReduction_202 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut73 happy_x_1 of { happy_var_1 -> + case happyOut50 happy_x_2 of { happy_var_2 -> + case happyOut56 happy_x_3 of { happy_var_3 -> + happyIn55+ (rev happy_var_1 ++ [happy_var_2] ++ happy_var_3+ )}}}++happyReduce_203 = happySpecReduce_1 41# happyReduction_203+happyReduction_203 happy_x_1+ = case happyOut82 happy_x_1 of { happy_var_1 -> + happyIn55+ ([happy_var_1]+ )}++happyReduce_204 = happySpecReduce_2 41# happyReduction_204+happyReduction_204 happy_x_2+ happy_x_1+ = case happyOut82 happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_2 of { happy_var_2 -> + happyIn55+ (happy_var_1 : rev happy_var_2+ )}}++happyReduce_205 = happySpecReduce_2 41# happyReduction_205+happyReduction_205 happy_x_2+ happy_x_1+ = case happyOut73 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_2 of { happy_var_2 -> + happyIn55+ (rev happy_var_1 ++ [happy_var_2]+ )}}++happyReduce_206 = happySpecReduce_3 41# happyReduction_206+happyReduction_206 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut73 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_2 of { happy_var_2 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + happyIn55+ (rev happy_var_1 ++ [happy_var_2] ++ rev happy_var_3+ )}}}++happyReduce_207 = happySpecReduce_0 42# happyReduction_207+happyReduction_207 = happyIn56+ ([]+ )++happyReduce_208 = happySpecReduce_1 42# happyReduction_208+happyReduction_208 happy_x_1+ = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn56+ ([happy_var_1]+ )}++happyReduce_209 = happySpecReduce_2 42# happyReduction_209+happyReduction_209 happy_x_2+ happy_x_1+ = case happyOut50 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_2 of { happy_var_2 -> + happyIn56+ (happy_var_1 : happy_var_2+ )}}++happyReduce_210 = happySpecReduce_1 42# happyReduction_210+happyReduction_210 happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + happyIn56+ ([happy_var_1]+ )}++happyReduce_211 = happySpecReduce_2 42# happyReduction_211+happyReduction_211 happy_x_2+ happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_2 of { happy_var_2 -> + happyIn56+ (happy_var_1 : happy_var_2+ )}}++happyReduce_212 = happySpecReduce_1 43# happyReduction_212+happyReduction_212 happy_x_1+ = case happyOut58 happy_x_1 of { happy_var_1 -> + happyIn57+ (rsingleton happy_var_1+ )}++happyReduce_213 = happySpecReduce_3 43# happyReduction_213+happyReduction_213 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut57 happy_x_1 of { happy_var_1 -> + case happyOut58 happy_x_3 of { happy_var_3 -> + happyIn57+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_214 = happySpecReduce_1 44# happyReduction_214+happyReduction_214 happy_x_1+ = case happyOut67 happy_x_1 of { happy_var_1 -> + happyIn58+ (let { (ident, declToDecl) = happy_var_1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Field (Just ident) (Just decl) Nothing (locOf decl)+ )}++happyReduce_215 = happySpecReduce_2 44# happyReduction_215+happyReduction_215 happy_x_2+ happy_x_1+ = case happyOut67 happy_x_1 of { happy_var_1 -> + happyIn58+ (let { (ident, declToDecl) = happy_var_1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Field (Just ident) (Just decl) Nothing (locOf decl)+ )}++happyReduce_216 = happySpecReduce_2 44# happyReduction_216+happyReduction_216 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut38 happy_x_2 of { happy_var_2 -> + happyIn58+ (Field Nothing Nothing (Just happy_var_2) (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_217 = happySpecReduce_3 44# happyReduction_217+happyReduction_217 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut67 happy_x_1 of { happy_var_1 -> + case happyOut38 happy_x_3 of { happy_var_3 -> + happyIn58+ (let { (ident, declToDecl) = happy_var_1+ ; decl = declToDecl (declRoot ident)+ }+ in+ Field (Just ident) (Just decl) (Just happy_var_3) (locOf decl)+ )}}++happyReduce_218 = happySpecReduce_2 45# happyReduction_218+happyReduction_218 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_2 of { happy_var_2 -> + happyIn59+ (TSenum (Just happy_var_2) [] [] (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_219 = happySpecReduce_3 45# happyReduction_219+happyReduction_219 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_2 of { happy_var_2 -> + case happyOut15 happy_x_3 of { happy_var_3 -> + happyIn59+ (TSenum (Just happy_var_3) [] happy_var_2 (happy_var_1 <--> happy_var_3)+ )}}}++happyReduce_220 = happyReduce 4# 45# happyReduction_220+happyReduction_220 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut60 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn59+ (TSenum Nothing (rev happy_var_3) [] (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_221 = happyReduce 5# 45# happyReduction_221+happyReduction_221 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_2 of { happy_var_2 -> + case happyOut60 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + happyIn59+ (TSenum (Just happy_var_2) (rev happy_var_4) [] (happy_var_1 <--> happy_var_5)+ ) `HappyStk` happyRest}}}}++happyReduce_222 = happySpecReduce_1 46# happyReduction_222+happyReduction_222 happy_x_1+ = case happyOut61 happy_x_1 of { happy_var_1 -> + happyIn60+ (rsingleton happy_var_1+ )}++happyReduce_223 = happySpecReduce_1 46# happyReduction_223+happyReduction_223 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn60+ (rsingleton (AntiEnums (getANTI_ENUMS happy_var_1) (locOf happy_var_1))+ )}++happyReduce_224 = happySpecReduce_2 46# happyReduction_224+happyReduction_224 happy_x_2+ happy_x_1+ = case happyOut60 happy_x_1 of { happy_var_1 -> + happyIn60+ (happy_var_1+ )}++happyReduce_225 = happySpecReduce_3 46# happyReduction_225+happyReduction_225 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut60 happy_x_1 of { happy_var_1 -> + case happyOut61 happy_x_3 of { happy_var_3 -> + happyIn60+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_226 = happySpecReduce_3 46# happyReduction_226+happyReduction_226 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut60 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn60+ (rcons (AntiEnums (getANTI_ENUMS happy_var_3) (locOf happy_var_3)) happy_var_1+ )}}++happyReduce_227 = happySpecReduce_1 47# happyReduction_227+happyReduction_227 happy_x_1+ = case happyOut14 happy_x_1 of { happy_var_1 -> + happyIn61+ (CEnum happy_var_1 Nothing (locOf happy_var_1)+ )}++happyReduce_228 = happySpecReduce_3 47# happyReduction_228+happyReduction_228 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut14 happy_x_1 of { happy_var_1 -> + case happyOut38 happy_x_3 of { happy_var_3 -> + happyIn61+ (CEnum happy_var_1 (Just happy_var_3) (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_229 = happySpecReduce_1 47# happyReduction_229+happyReduction_229 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn61+ (AntiEnum (getANTI_ENUM happy_var_1) (locOf happy_var_1)+ )}++happyReduce_230 = happySpecReduce_1 48# happyReduction_230+happyReduction_230 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSconst (locOf happy_var_1)+ )}++happyReduce_231 = happySpecReduce_1 48# happyReduction_231+happyReduction_231 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSinline (locOf happy_var_1)+ )}++happyReduce_232 = happySpecReduce_1 48# happyReduction_232+happyReduction_232 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSrestrict (locOf happy_var_1)+ )}++happyReduce_233 = happySpecReduce_1 48# happyReduction_233+happyReduction_233 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSvolatile (locOf happy_var_1)+ )}++happyReduce_234 = happySpecReduce_1 48# happyReduction_234+happyReduction_234 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSdevice (locOf happy_var_1)+ )}++happyReduce_235 = happySpecReduce_1 48# happyReduction_235+happyReduction_235 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSglobal (locOf happy_var_1)+ )}++happyReduce_236 = happySpecReduce_1 48# happyReduction_236+happyReduction_236 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TShost (locOf happy_var_1)+ )}++happyReduce_237 = happySpecReduce_1 48# happyReduction_237+happyReduction_237 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSconstant (locOf happy_var_1)+ )}++happyReduce_238 = happySpecReduce_1 48# happyReduction_238+happyReduction_238 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSshared (locOf happy_var_1)+ )}++happyReduce_239 = happySpecReduce_1 48# happyReduction_239+happyReduction_239 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn62+ (TSnoinline (locOf happy_var_1)+ )}++happyReduce_240 = happySpecReduce_1 49# happyReduction_240+happyReduction_240 happy_x_1+ = case happyOut64 happy_x_1 of { happy_var_1 -> + happyIn63+ (happy_var_1+ )}++happyReduce_241 = happySpecReduce_2 49# happyReduction_241+happyReduction_241 happy_x_2+ happy_x_1+ = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOut64 happy_x_2 of { happy_var_2 -> + happyIn63+ (let (ident, dirDecl) = happy_var_2+ in+ (ident, dirDecl . happy_var_1)+ )}}++happyReduce_242 = happySpecReduce_1 50# happyReduction_242+happyReduction_242 happy_x_1+ = case happyOut14 happy_x_1 of { happy_var_1 -> + happyIn64+ ((happy_var_1, id)+ )}++happyReduce_243 = happySpecReduce_3 50# happyReduction_243+happyReduction_243 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut63 happy_x_2 of { happy_var_2 -> + happyIn64+ (happy_var_2+ )}++happyReduce_244 = happyMonadReduce 3# 50# happyReduction_244+happyReduction_244 (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 happyOut63 happy_x_2 of { happy_var_2 -> + (do { let (ident, declToDecl) = happy_var_2+ ; let decl = declToDecl (declRoot ident)+ ; unclosed (happy_var_1 <--> decl) "("+ })}}+ ) (\r -> happyReturn (happyIn64 r))++happyReduce_245 = happySpecReduce_2 50# happyReduction_245+happyReduction_245 happy_x_2+ happy_x_1+ = case happyOut64 happy_x_1 of { happy_var_1 -> + case happyOut71 happy_x_2 of { happy_var_2 -> + happyIn64+ (let (ident, declToDecl) = happy_var_1+ in+ (ident, declToDecl . happy_var_2)+ )}}++happyReduce_246 = happySpecReduce_3 50# happyReduction_246+happyReduction_246 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut64 happy_x_1 of { happy_var_1 -> + happyIn64+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkOldProto []+ }+ in+ (ident, declToDecl . proto)+ )}++happyReduce_247 = happyReduce 4# 50# happyReduction_247+happyReduction_247 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut64 happy_x_1 of { happy_var_1 -> + case happyOut74 happy_x_3 of { happy_var_3 -> + happyIn64+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkProto happy_var_3+ }+ in+ (ident, declToDecl . proto)+ ) `HappyStk` happyRest}}++happyReduce_248 = happyReduce 4# 50# happyReduction_248+happyReduction_248 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut64 happy_x_1 of { happy_var_1 -> + case happyOut78 happy_x_3 of { happy_var_3 -> + happyIn64+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkOldProto (rev happy_var_3)+ }+ in+ (ident, declToDecl . proto)+ ) `HappyStk` happyRest}}++happyReduce_249 = happySpecReduce_1 51# happyReduction_249+happyReduction_249 happy_x_1+ = case happyOut66 happy_x_1 of { happy_var_1 -> + happyIn65+ (happy_var_1+ )}++happyReduce_250 = happySpecReduce_2 51# happyReduction_250+happyReduction_250 happy_x_2+ happy_x_1+ = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_2 of { happy_var_2 -> + happyIn65+ (let (ident, dirDecl) = happy_var_2+ in+ (ident, dirDecl . happy_var_1)+ )}}++happyReduce_251 = happySpecReduce_1 52# happyReduction_251+happyReduction_251 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn66+ ((Id (getNAMED happy_var_1) (locOf happy_var_1), id)+ )}++happyReduce_252 = happySpecReduce_3 52# happyReduction_252+happyReduction_252 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut65 happy_x_2 of { happy_var_2 -> + happyIn66+ (happy_var_2+ )}++happyReduce_253 = happyMonadReduce 3# 52# happyReduction_253+happyReduction_253 (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 happyOut65 happy_x_2 of { happy_var_2 -> + (do { let (ident, declToDecl) = happy_var_2+ ; let decl = declToDecl (declRoot ident)+ ; unclosed (happy_var_1 <--> decl) "("+ })}}+ ) (\r -> happyReturn (happyIn66 r))++happyReduce_254 = happySpecReduce_2 52# happyReduction_254+happyReduction_254 happy_x_2+ happy_x_1+ = case happyOut66 happy_x_1 of { happy_var_1 -> + case happyOut71 happy_x_2 of { happy_var_2 -> + happyIn66+ (let (ident, declToDecl) = happy_var_1+ in+ (ident, declToDecl . happy_var_2)+ )}}++happyReduce_255 = happySpecReduce_3 52# happyReduction_255+happyReduction_255 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut66 happy_x_1 of { happy_var_1 -> + happyIn66+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkOldProto []+ }+ in+ (ident, declToDecl . proto)+ )}++happyReduce_256 = happyReduce 4# 52# happyReduction_256+happyReduction_256 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut66 happy_x_1 of { happy_var_1 -> + case happyOut74 happy_x_3 of { happy_var_3 -> + happyIn66+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkProto happy_var_3+ }+ in+ (ident, declToDecl . proto)+ ) `HappyStk` happyRest}}++happyReduce_257 = happyReduce 4# 52# happyReduction_257+happyReduction_257 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut66 happy_x_1 of { happy_var_1 -> + case happyOut78 happy_x_3 of { happy_var_3 -> + happyIn66+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkOldProto (rev happy_var_3)+ }+ in+ (ident, declToDecl . proto)+ ) `HappyStk` happyRest}}++happyReduce_258 = happySpecReduce_1 53# happyReduction_258+happyReduction_258 happy_x_1+ = case happyOut63 happy_x_1 of { happy_var_1 -> + happyIn67+ (happy_var_1+ )}++happyReduce_259 = happySpecReduce_1 53# happyReduction_259+happyReduction_259 happy_x_1+ = case happyOut65 happy_x_1 of { happy_var_1 -> + happyIn67+ (happy_var_1+ )}++happyReduce_260 = happySpecReduce_1 54# happyReduction_260+happyReduction_260 happy_x_1+ = case happyOut69 happy_x_1 of { happy_var_1 -> + happyIn68+ (happy_var_1+ )}++happyReduce_261 = happySpecReduce_2 54# happyReduction_261+happyReduction_261 happy_x_2+ happy_x_1+ = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOut69 happy_x_2 of { happy_var_2 -> + happyIn68+ (let (ident, dirDecl) = happy_var_2+ in+ (ident, dirDecl . happy_var_1)+ )}}++happyReduce_262 = happySpecReduce_1 55# happyReduction_262+happyReduction_262 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn69+ ((Id (getNAMED happy_var_1) (locOf happy_var_1), id)+ )}++happyReduce_263 = happyReduce 4# 55# happyReduction_263+happyReduction_263 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut72 happy_x_2 of { happy_var_2 -> + case happyOut69 happy_x_3 of { happy_var_3 -> + happyIn69+ (let (ident, dirDecl) = happy_var_3+ in+ (ident, dirDecl . happy_var_2)+ ) `HappyStk` happyRest}}++happyReduce_264 = happySpecReduce_2 55# happyReduction_264+happyReduction_264 happy_x_2+ happy_x_1+ = case happyOut69 happy_x_1 of { happy_var_1 -> + case happyOut71 happy_x_2 of { happy_var_2 -> + happyIn69+ (let (ident, declToDecl) = happy_var_1+ in+ (ident, declToDecl . happy_var_2)+ )}}++happyReduce_265 = happySpecReduce_3 55# happyReduction_265+happyReduction_265 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut69 happy_x_1 of { happy_var_1 -> + happyIn69+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkOldProto []+ }+ in+ (ident, declToDecl . proto)+ )}++happyReduce_266 = happyReduce 4# 55# happyReduction_266+happyReduction_266 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut69 happy_x_1 of { happy_var_1 -> + case happyOut74 happy_x_3 of { happy_var_3 -> + happyIn69+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkProto happy_var_3+ }+ in+ (ident, declToDecl . proto)+ ) `HappyStk` happyRest}}++happyReduce_267 = happyReduce 4# 55# happyReduction_267+happyReduction_267 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut69 happy_x_1 of { happy_var_1 -> + case happyOut78 happy_x_3 of { happy_var_3 -> + happyIn69+ (let { (ident, declToDecl) = happy_var_1+ ; proto = mkOldProto (rev happy_var_3)+ }+ in+ (ident, declToDecl . proto)+ ) `HappyStk` happyRest}}++happyReduce_268 = happySpecReduce_1 56# happyReduction_268+happyReduction_268 happy_x_1+ = case happyOut63 happy_x_1 of { happy_var_1 -> + happyIn70+ (happy_var_1+ )}++happyReduce_269 = happySpecReduce_1 56# happyReduction_269+happyReduction_269 happy_x_1+ = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn70+ (happy_var_1+ )}++happyReduce_270 = happySpecReduce_2 57# happyReduction_270+happyReduction_270 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn71+ (mkArray [] (NoArraySize (happy_var_1 <--> happy_var_2))+ )}}++happyReduce_271 = happyMonadReduce 2# 57# happyReduction_271+happyReduction_271 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( unclosed (getLoc happy_var_1) "[")}+ ) (\r -> happyReturn (happyIn71 r))++happyReduce_272 = happySpecReduce_3 57# happyReduction_272+happyReduction_272 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn71+ (mkArray (rev happy_var_2) (NoArraySize (happy_var_1 <--> happy_var_3))+ )}}}++happyReduce_273 = happySpecReduce_3 57# happyReduction_273+happyReduction_273 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut35 happy_x_2 of { happy_var_2 -> + happyIn71+ (mkArray [] (ArraySize False happy_var_2 (locOf happy_var_2))+ )}++happyReduce_274 = happyReduce 4# 57# happyReduction_274+happyReduction_274 (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 happyOut35 happy_x_3 of { happy_var_3 -> + happyIn71+ (mkArray (rev happy_var_2) (ArraySize False happy_var_3 (locOf happy_var_3))+ ) `HappyStk` happyRest}}++happyReduce_275 = happyReduce 4# 57# happyReduction_275+happyReduction_275 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn71+ (mkArray [] (ArraySize True happy_var_3 (locOf happy_var_3))+ ) `HappyStk` happyRest}++happyReduce_276 = happyReduce 5# 57# happyReduction_276+happyReduction_276 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut73 happy_x_3 of { happy_var_3 -> + case happyOut35 happy_x_4 of { happy_var_4 -> + happyIn71+ (mkArray (rev happy_var_3) (ArraySize True happy_var_4 (locOf happy_var_4))+ ) `HappyStk` happyRest}}++happyReduce_277 = happyReduce 5# 57# happyReduction_277+happyReduction_277 (happy_x_5 `HappyStk`+ 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 happyOut35 happy_x_4 of { happy_var_4 -> + happyIn71+ (mkArray (rev happy_var_2) (ArraySize True happy_var_4 (locOf happy_var_4))+ ) `HappyStk` happyRest}}++happyReduce_278 = happySpecReduce_3 57# happyReduction_278+happyReduction_278 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn71+ (mkArray [] (VariableArraySize (happy_var_1 <--> happy_var_3))+ )}}++happyReduce_279 = happyReduce 4# 57# happyReduction_279+happyReduction_279 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn71+ (mkArray (rev happy_var_2) (VariableArraySize (happy_var_1 <--> happy_var_4))+ ) `HappyStk` happyRest}}}++happyReduce_280 = happySpecReduce_1 58# happyReduction_280+happyReduction_280 happy_x_1+ = happyIn72+ (mkPtr []+ )++happyReduce_281 = happySpecReduce_2 58# happyReduction_281+happyReduction_281 happy_x_2+ happy_x_1+ = case happyOut73 happy_x_2 of { happy_var_2 -> + happyIn72+ (mkPtr (rev happy_var_2)+ )}++happyReduce_282 = happySpecReduce_2 58# happyReduction_282+happyReduction_282 happy_x_2+ happy_x_1+ = case happyOut72 happy_x_2 of { happy_var_2 -> + happyIn72+ (happy_var_2 . mkPtr []+ )}++happyReduce_283 = happySpecReduce_3 58# happyReduction_283+happyReduction_283 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut73 happy_x_2 of { happy_var_2 -> + case happyOut72 happy_x_3 of { happy_var_3 -> + happyIn72+ (happy_var_3 . mkPtr (rev happy_var_2)+ )}}++happyReduce_284 = happySpecReduce_1 59# happyReduction_284+happyReduction_284 happy_x_1+ = case happyOut62 happy_x_1 of { happy_var_1 -> + happyIn73+ (rsingleton happy_var_1+ )}++happyReduce_285 = happySpecReduce_2 59# happyReduction_285+happyReduction_285 happy_x_2+ happy_x_1+ = case happyOut73 happy_x_1 of { happy_var_1 -> + case happyOut62 happy_x_2 of { happy_var_2 -> + happyIn73+ (rcons happy_var_2 happy_var_1+ )}}++happyReduce_286 = happySpecReduce_1 60# happyReduction_286+happyReduction_286 happy_x_1+ = case happyOut75 happy_x_1 of { happy_var_1 -> + happyIn74+ (let params = rev happy_var_1+ in+ Params params False (locOf params)+ )}++happyReduce_287 = happySpecReduce_3 60# happyReduction_287+happyReduction_287 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn74+ (let params = rev happy_var_1+ in+ Params params True (params <--> happy_var_3)+ )}}++happyReduce_288 = happySpecReduce_1 61# happyReduction_288+happyReduction_288 happy_x_1+ = case happyOut76 happy_x_1 of { happy_var_1 -> + happyIn75+ (rsingleton happy_var_1+ )}++happyReduce_289 = happySpecReduce_1 61# happyReduction_289+happyReduction_289 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn75+ (rsingleton (AntiParams (getANTI_PARAMS happy_var_1) (locOf happy_var_1))+ )}++happyReduce_290 = happySpecReduce_3 61# happyReduction_290+happyReduction_290 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_3 of { happy_var_3 -> + happyIn75+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_291 = happySpecReduce_3 61# happyReduction_291+happyReduction_291 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn75+ (rcons (AntiParams (getANTI_PARAMS happy_var_3) (locOf happy_var_3)) happy_var_1+ )}}++happyReduce_292 = happySpecReduce_1 62# happyReduction_292+happyReduction_292 happy_x_1+ = case happyOut41 happy_x_1 of { happy_var_1 -> + happyIn76+ (let (dspec, decl) = happy_var_1+ in+ Param Nothing dspec decl (dspec <--> decl)+ )}++happyReduce_293 = happySpecReduce_2 62# happyReduction_293+happyReduction_293 happy_x_2+ happy_x_1+ = case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut70 happy_x_2 of { happy_var_2 -> + happyIn76+ (let { (dspec, declRoot) = happy_var_1+ ; (ident, declToDecl) = happy_var_2+ ; decl = declToDecl declRoot+ }+ in+ Param (Just ident) dspec decl (ident <--> decl)+ )}}++happyReduce_294 = happySpecReduce_2 62# happyReduction_294+happyReduction_294 happy_x_2+ happy_x_1+ = case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn76+ (let { (dspec, declRoot) = happy_var_1+ ; decl = happy_var_2 declRoot+ }+ in+ Param Nothing dspec decl (dspec <--> decl)+ )}}++happyReduce_295 = happySpecReduce_1 62# happyReduction_295+happyReduction_295 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn76+ (AntiParam (getANTI_PARAM happy_var_1) (locOf happy_var_1)+ )}++happyReduce_296 = happySpecReduce_1 63# happyReduction_296+happyReduction_296 happy_x_1+ = case happyOut41 happy_x_1 of { happy_var_1 -> + happyIn77+ (let (dspec, decl) = happy_var_1+ in+ Type dspec decl (dspec <--> decl)+ )}++happyReduce_297 = happySpecReduce_2 63# happyReduction_297+happyReduction_297 happy_x_2+ happy_x_1+ = case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut70 happy_x_2 of { happy_var_2 -> + happyIn77+ (let { (dspec, declRoot) = happy_var_1+ ; (ident, declToDecl) = happy_var_2+ ; decl = declToDecl declRoot+ }+ in+ Type dspec decl (dspec <--> decl)+ )}}++happyReduce_298 = happySpecReduce_2 63# happyReduction_298+happyReduction_298 happy_x_2+ happy_x_1+ = case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn77+ (let { (dspec, declRoot) = happy_var_1+ ; decl = happy_var_2 declRoot+ }+ in+ Type dspec decl (dspec <--> decl)+ )}}++happyReduce_299 = happySpecReduce_1 64# happyReduction_299+happyReduction_299 happy_x_1+ = case happyOut14 happy_x_1 of { happy_var_1 -> + happyIn78+ (rsingleton happy_var_1+ )}++happyReduce_300 = happySpecReduce_3 64# happyReduction_300+happyReduction_300 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut78 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + happyIn78+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_301 = happySpecReduce_1 65# happyReduction_301+happyReduction_301 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn79+ (let dspec = AntiDeclSpec (getANTI_SPEC happy_var_1) (locOf happy_var_1)+ in+ Type dspec (declRoot happy_var_1) (locOf happy_var_1)+ )}++happyReduce_302 = happyMonadReduce 1# 65# happyReduction_302+happyReduction_302 (happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut55 happy_x_1 of { happy_var_1 -> + ( do{ dspec <- mkDeclSpec happy_var_1+ ; return $ Type dspec (declRoot happy_var_1) (locOf happy_var_1)+ })}+ ) (\r -> happyReturn (happyIn79 r))++happyReduce_303 = happySpecReduce_2 65# happyReduction_303+happyReduction_303 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn79+ (let { dspec = AntiDeclSpec (getANTI_SPEC happy_var_1) (locOf happy_var_1)+ ; decl = happy_var_2 (declRoot happy_var_1)+ }+ in+ Type dspec decl (dspec <--> decl)+ )}}++happyReduce_304 = happyMonadReduce 2# 65# happyReduction_304+happyReduction_304 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut55 happy_x_1 of { happy_var_1 -> + case happyOut80 happy_x_2 of { happy_var_2 -> + ( do{ let decl = happy_var_2 (declRoot happy_var_1)+ ; dspec <- mkDeclSpec happy_var_1+ ; return $ Type dspec decl (dspec <--> decl)+ })}}+ ) (\r -> happyReturn (happyIn79 r))++happyReduce_305 = happySpecReduce_1 65# happyReduction_305+happyReduction_305 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn79+ (AntiType (getANTI_TYPE happy_var_1) (locOf happy_var_1)+ )}++happyReduce_306 = happySpecReduce_2 65# happyReduction_306+happyReduction_306 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn79+ (let { v = getANTI_TYPE happy_var_1+ ; decl = happy_var_2 (AntiTypeDecl v (locOf happy_var_1))+ }+ in+ Type (AntiTypeDeclSpec [] [] v (locOf happy_var_1)) decl (happy_var_1 <--> decl)+ )}}++happyReduce_307 = happySpecReduce_1 66# happyReduction_307+happyReduction_307 happy_x_1+ = case happyOut72 happy_x_1 of { happy_var_1 -> + happyIn80+ (happy_var_1+ )}++happyReduce_308 = happySpecReduce_1 66# happyReduction_308+happyReduction_308 happy_x_1+ = case happyOut81 happy_x_1 of { happy_var_1 -> + happyIn80+ (happy_var_1+ )}++happyReduce_309 = happySpecReduce_2 66# happyReduction_309+happyReduction_309 happy_x_2+ happy_x_1+ = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOut81 happy_x_2 of { happy_var_2 -> + happyIn80+ (happy_var_2 . happy_var_1+ )}}++happyReduce_310 = happySpecReduce_3 67# happyReduction_310+happyReduction_310 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn81+ (happy_var_2+ )}++happyReduce_311 = happyMonadReduce 3# 67# happyReduction_311+happyReduction_311 (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 happyOut80 happy_x_2 of { happy_var_2 -> + ( do{ let decl = happy_var_2 (declRoot happy_var_1)+ ; unclosed (happy_var_1 <--> decl) "("+ })}}+ ) (\r -> happyReturn (happyIn81 r))++happyReduce_312 = happySpecReduce_1 67# happyReduction_312+happyReduction_312 happy_x_1+ = case happyOut71 happy_x_1 of { happy_var_1 -> + happyIn81+ (happy_var_1+ )}++happyReduce_313 = happySpecReduce_2 67# happyReduction_313+happyReduction_313 happy_x_2+ happy_x_1+ = case happyOut81 happy_x_1 of { happy_var_1 -> + case happyOut71 happy_x_2 of { happy_var_2 -> + happyIn81+ (happy_var_1 . happy_var_2+ )}}++happyReduce_314 = happySpecReduce_2 67# happyReduction_314+happyReduction_314 happy_x_2+ happy_x_1+ = happyIn81+ (mkOldProto []+ )++happyReduce_315 = happySpecReduce_3 67# happyReduction_315+happyReduction_315 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut74 happy_x_2 of { happy_var_2 -> + happyIn81+ (mkProto happy_var_2+ )}++happyReduce_316 = happySpecReduce_3 67# happyReduction_316+happyReduction_316 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut81 happy_x_1 of { happy_var_1 -> + happyIn81+ (happy_var_1 . mkOldProto []+ )}++happyReduce_317 = happyReduce 4# 67# happyReduction_317+happyReduction_317 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut81 happy_x_1 of { happy_var_1 -> + case happyOut74 happy_x_3 of { happy_var_3 -> + happyIn81+ (happy_var_1 . mkProto happy_var_3+ ) `HappyStk` happyRest}}++happyReduce_318 = happySpecReduce_1 68# happyReduction_318+happyReduction_318 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn82+ (TSnamed (Id (getNAMED happy_var_1) (locOf happy_var_1)) (locOf happy_var_1)+ )}++happyReduce_319 = happySpecReduce_2 68# happyReduction_319+happyReduction_319 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn82+ (TSnamed happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_320 = happyMonadReduce 2# 68# happyReduction_320+happyReduction_320 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( expected (locOf happy_var_1) ["identifier"])}+ ) (\r -> happyReturn (happyIn82 r))++happyReduce_321 = happyReduce 4# 68# happyReduction_321+happyReduction_321 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn82+ (TStypeofExp happy_var_3 (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_322 = happyReduce 4# 68# happyReduction_322+happyReduction_322 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut79 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn82+ (TStypeofType happy_var_3 (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_323 = happyMonadReduce 4# 68# happyReduction_323+happyReduction_323 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut79 happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_2 <--> happy_var_3) "(")}}+ ) (\r -> happyReturn (happyIn82 r))++happyReduce_324 = happySpecReduce_1 69# happyReduction_324+happyReduction_324 happy_x_1+ = case happyOut35 happy_x_1 of { happy_var_1 -> + happyIn83+ (ExpInitializer happy_var_1 (locOf happy_var_1)+ )}++happyReduce_325 = happySpecReduce_3 69# happyReduction_325+happyReduction_325 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn83+ (CompoundInitializer (rev happy_var_2) (happy_var_1 <--> happy_var_3)+ )}}}++happyReduce_326 = happyMonadReduce 3# 69# happyReduction_326+happyReduction_326 (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 happyOut84 happy_x_2 of { happy_var_2 -> + ( do{ let (_, inits) = unzip (rev happy_var_2)+ ; unclosed (happy_var_1 <--> inits) "{"+ })}}+ ) (\r -> happyReturn (happyIn83 r))++happyReduce_327 = happyReduce 4# 69# happyReduction_327+happyReduction_327 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn83+ (CompoundInitializer (rev happy_var_2) (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_328 = happyMonadReduce 4# 69# 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 happyOutTok happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_1 <--> happy_var_3) "{")}}+ ) (\r -> happyReturn (happyIn83 r))++happyReduce_329 = happySpecReduce_1 70# happyReduction_329+happyReduction_329 happy_x_1+ = case happyOut83 happy_x_1 of { happy_var_1 -> + happyIn84+ (rsingleton (Nothing, happy_var_1)+ )}++happyReduce_330 = happySpecReduce_2 70# happyReduction_330+happyReduction_330 happy_x_2+ happy_x_1+ = case happyOut85 happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_2 of { happy_var_2 -> + happyIn84+ (rsingleton (Just happy_var_1, happy_var_2)+ )}}++happyReduce_331 = happySpecReduce_3 70# happyReduction_331+happyReduction_331 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut84 happy_x_1 of { happy_var_1 -> + case happyOut83 happy_x_3 of { happy_var_3 -> + happyIn84+ (rcons (Nothing, happy_var_3) happy_var_1+ )}}++happyReduce_332 = happyReduce 4# 70# happyReduction_332+happyReduction_332 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut84 happy_x_1 of { happy_var_1 -> + case happyOut85 happy_x_3 of { happy_var_3 -> + case happyOut83 happy_x_4 of { happy_var_4 -> + happyIn84+ (rcons (Just happy_var_3, happy_var_4) happy_var_1+ ) `HappyStk` happyRest}}}++happyReduce_333 = happySpecReduce_2 71# happyReduction_333+happyReduction_333 happy_x_2+ happy_x_1+ = case happyOut86 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn85+ (let designators = rev happy_var_1+ in+ Designation designators (designators <--> happy_var_2)+ )}}++happyReduce_334 = happySpecReduce_1 72# happyReduction_334+happyReduction_334 happy_x_1+ = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn86+ (rsingleton happy_var_1+ )}++happyReduce_335 = happySpecReduce_2 72# happyReduction_335+happyReduction_335 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+ (rcons happy_var_2 happy_var_1+ )}}++happyReduce_336 = happySpecReduce_3 73# happyReduction_336+happyReduction_336 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut38 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn87+ (IndexDesignator happy_var_2 (happy_var_1 <--> happy_var_3)+ )}}}++happyReduce_337 = happySpecReduce_2 73# happyReduction_337+happyReduction_337 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn87+ (MemberDesignator happy_var_2 (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_338 = happySpecReduce_1 74# happyReduction_338+happyReduction_338 happy_x_1+ = case happyOut89 happy_x_1 of { happy_var_1 -> + happyIn88+ (happy_var_1+ )}++happyReduce_339 = happySpecReduce_1 74# happyReduction_339+happyReduction_339 happy_x_1+ = case happyOut90 happy_x_1 of { happy_var_1 -> + happyIn88+ (happy_var_1+ )}++happyReduce_340 = happySpecReduce_1 74# happyReduction_340+happyReduction_340 happy_x_1+ = case happyOut96 happy_x_1 of { happy_var_1 -> + happyIn88+ (happy_var_1+ )}++happyReduce_341 = happySpecReduce_1 74# happyReduction_341+happyReduction_341 happy_x_1+ = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn88+ (happy_var_1+ )}++happyReduce_342 = happySpecReduce_1 74# happyReduction_342+happyReduction_342 happy_x_1+ = case happyOut98 happy_x_1 of { happy_var_1 -> + happyIn88+ (happy_var_1+ )}++happyReduce_343 = happySpecReduce_1 74# happyReduction_343+happyReduction_343 happy_x_1+ = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn88+ (happy_var_1+ )}++happyReduce_344 = happySpecReduce_1 74# happyReduction_344+happyReduction_344 happy_x_1+ = case happyOut110 happy_x_1 of { happy_var_1 -> + happyIn88+ (happy_var_1+ )}++happyReduce_345 = happySpecReduce_1 74# happyReduction_345+happyReduction_345 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn88+ (AntiStm (getANTI_STM happy_var_1) (locOf happy_var_1)+ )}++happyReduce_346 = happySpecReduce_3 75# happyReduction_346+happyReduction_346 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut14 happy_x_1 of { happy_var_1 -> + case happyOut88 happy_x_3 of { happy_var_3 -> + happyIn89+ (Label happy_var_1 happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_347 = happyReduce 4# 75# happyReduction_347+happyReduction_347 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut38 happy_x_2 of { happy_var_2 -> + case happyOut88 happy_x_4 of { happy_var_4 -> + happyIn89+ (Case happy_var_2 happy_var_4 (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_348 = happySpecReduce_3 75# happyReduction_348+happyReduction_348 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut88 happy_x_3 of { happy_var_3 -> + happyIn89+ (Default happy_var_3 (happy_var_1 <--> happy_var_3)+ )}}++happyReduce_349 = happyReduce 4# 76# happyReduction_349+happyReduction_349 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn90+ (Block [] (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}++happyReduce_350 = happyMonadReduce 3# 76# happyReduction_350+happyReduction_350 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_3 of { happy_var_3 -> + ( unclosed (locOf happy_var_3) "{")}+ ) (\r -> happyReturn (happyIn90 r))++happyReduce_351 = happyReduce 5# 76# happyReduction_351+happyReduction_351 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut91 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + happyIn90+ (Block (rev happy_var_3) (happy_var_1 <--> happy_var_5)+ ) `HappyStk` happyRest}}}++happyReduce_352 = happySpecReduce_1 77# happyReduction_352+happyReduction_352 happy_x_1+ = case happyOut92 happy_x_1 of { happy_var_1 -> + happyIn91+ (rsingleton happy_var_1+ )}++happyReduce_353 = happySpecReduce_2 77# happyReduction_353+happyReduction_353 happy_x_2+ happy_x_1+ = case happyOut91 happy_x_1 of { happy_var_1 -> + case happyOut92 happy_x_2 of { happy_var_2 -> + happyIn91+ (rcons happy_var_2 happy_var_1+ )}}++happyReduce_354 = happySpecReduce_1 78# happyReduction_354+happyReduction_354 happy_x_1+ = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn92+ (BlockDecl happy_var_1+ )}++happyReduce_355 = happySpecReduce_1 78# happyReduction_355+happyReduction_355 happy_x_1+ = case happyOut88 happy_x_1 of { happy_var_1 -> + happyIn92+ (BlockStm happy_var_1+ )}++happyReduce_356 = happySpecReduce_1 78# happyReduction_356+happyReduction_356 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn92+ (BlockDecl (AntiDecls (getANTI_DECLS happy_var_1) (locOf happy_var_1))+ )}++happyReduce_357 = happySpecReduce_1 78# happyReduction_357+happyReduction_357 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn92+ (BlockStm (AntiStms (getANTI_STMS happy_var_1) (locOf happy_var_1))+ )}++happyReduce_358 = happySpecReduce_1 78# happyReduction_358+happyReduction_358 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn92+ (AntiBlockItem (getANTI_ITEM happy_var_1) (locOf happy_var_1)+ )}++happyReduce_359 = happySpecReduce_1 78# happyReduction_359+happyReduction_359 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn92+ (AntiBlockItems (getANTI_ITEMS happy_var_1) (locOf happy_var_1)+ )}++happyReduce_360 = happyMonadReduce 0# 79# happyReduction_360+happyReduction_360 (happyRest) tk+ = happyThen (( pushScope)+ ) (\r -> happyReturn (happyIn93 r))++happyReduce_361 = happyMonadReduce 0# 80# happyReduction_361+happyReduction_361 (happyRest) tk+ = happyThen (( popScope)+ ) (\r -> happyReturn (happyIn94 r))++happyReduce_362 = happySpecReduce_1 81# happyReduction_362+happyReduction_362 happy_x_1+ = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn95+ (rsingleton happy_var_1+ )}++happyReduce_363 = happySpecReduce_1 81# happyReduction_363+happyReduction_363 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn95+ (rsingleton (AntiDecls (getANTI_DECLS happy_var_1) (locOf happy_var_1))+ )}++happyReduce_364 = happySpecReduce_2 81# happyReduction_364+happyReduction_364 happy_x_2+ happy_x_1+ = case happyOut95 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_2 of { happy_var_2 -> + happyIn95+ (rcons happy_var_2 happy_var_1+ )}}++happyReduce_365 = happySpecReduce_2 81# happyReduction_365+happyReduction_365 happy_x_2+ happy_x_1+ = case happyOut95 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn95+ (rcons (AntiDecls (getANTI_DECLS happy_var_2) (locOf happy_var_2)) happy_var_1+ )}}++happyReduce_366 = happySpecReduce_1 82# happyReduction_366+happyReduction_366 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn96+ (Exp Nothing (locOf happy_var_1)+ )}++happyReduce_367 = happySpecReduce_2 82# happyReduction_367+happyReduction_367 happy_x_2+ happy_x_1+ = case happyOut36 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn96+ (Exp (Just happy_var_1) (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_368 = happyMonadReduce 2# 82# happyReduction_368+happyReduction_368 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut36 happy_x_1 of { happy_var_1 -> + ( expected (locOf happy_var_1) ["';'"])}+ ) (\r -> happyReturn (happyIn96 r))++happyReduce_369 = happyReduce 5# 83# happyReduction_369+happyReduction_369 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + case happyOut88 happy_x_5 of { happy_var_5 -> + happyIn97+ (If happy_var_3 happy_var_5 Nothing (happy_var_1 <--> happy_var_5)+ ) `HappyStk` happyRest}}}++happyReduce_370 = happyReduce 7# 83# happyReduction_370+happyReduction_370 (happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + case happyOut88 happy_x_5 of { happy_var_5 -> + case happyOut88 happy_x_7 of { happy_var_7 -> + happyIn97+ (If happy_var_3 happy_var_5 (Just happy_var_7) (happy_var_1 <--> happy_var_7)+ ) `HappyStk` happyRest}}}}++happyReduce_371 = happyMonadReduce 4# 83# happyReduction_371+happyReduction_371 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_2 <--> happy_var_3) "(")}}+ ) (\r -> happyReturn (happyIn97 r))++happyReduce_372 = happyReduce 5# 83# happyReduction_372+happyReduction_372 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + case happyOut88 happy_x_5 of { happy_var_5 -> + happyIn97+ (Switch happy_var_3 happy_var_5 (happy_var_1 <--> happy_var_5)+ ) `HappyStk` happyRest}}}++happyReduce_373 = happyMonadReduce 4# 83# happyReduction_373+happyReduction_373 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_2 <--> happy_var_3) "(")}}+ ) (\r -> happyReturn (happyIn97 r))++happyReduce_374 = happyReduce 5# 84# happyReduction_374+happyReduction_374 (happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + case happyOut88 happy_x_5 of { happy_var_5 -> + happyIn98+ (While happy_var_3 happy_var_5 (happy_var_1 <--> happy_var_5)+ ) `HappyStk` happyRest}}}++happyReduce_375 = happyMonadReduce 4# 84# happyReduction_375+happyReduction_375 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + ( unclosed (happy_var_2 <--> happy_var_3) "(")}}+ ) (\r -> happyReturn (happyIn98 r))++happyReduce_376 = happyReduce 7# 84# happyReduction_376+happyReduction_376 (happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut88 happy_x_2 of { happy_var_2 -> + case happyOut36 happy_x_5 of { happy_var_5 -> + case happyOutTok happy_x_7 of { happy_var_7 -> + happyIn98+ (DoWhile happy_var_2 happy_var_5 (happy_var_1 <--> happy_var_7)+ ) `HappyStk` happyRest}}}}++happyReduce_377 = happyMonadReduce 6# 84# happyReduction_377+happyReduction_377 (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_4 of { happy_var_4 -> + case happyOut36 happy_x_5 of { happy_var_5 -> + ( unclosed (happy_var_4 <--> happy_var_5) "(")}}+ ) (\r -> happyReturn (happyIn98 r))++happyReduce_378 = happyMonadReduce 3# 84# happyReduction_378+happyReduction_378 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_2 of { happy_var_2 -> + ( expected (locOf happy_var_2) ["expression", "declaration"])}+ ) (\r -> happyReturn (happyIn98 r))++happyReduce_379 = happyReduce 7# 84# happyReduction_379+happyReduction_379 (happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_3 of { happy_var_3 -> + case happyOut37 happy_x_4 of { happy_var_4 -> + case happyOut88 happy_x_7 of { happy_var_7 -> + happyIn98+ (For (Left happy_var_3) happy_var_4 Nothing happy_var_7 (happy_var_1 <--> happy_var_7)+ ) `HappyStk` happyRest}}}}++happyReduce_380 = happyReduce 8# 84# happyReduction_380+happyReduction_380 (happy_x_8 `HappyStk`+ happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut37 happy_x_3 of { happy_var_3 -> + case happyOut37 happy_x_5 of { happy_var_5 -> + case happyOut88 happy_x_8 of { happy_var_8 -> + happyIn98+ (For (Right happy_var_3) happy_var_5 Nothing happy_var_8 (happy_var_1 <--> happy_var_8)+ ) `HappyStk` happyRest}}}}++happyReduce_381 = happyMonadReduce 7# 84# happyReduction_381+happyReduction_381 (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_2 of { happy_var_2 -> + case happyOutTok happy_x_6 of { happy_var_6 -> + ( unclosed (happy_var_2 <--> happy_var_6) "(")}}+ ) (\r -> happyReturn (happyIn98 r))++happyReduce_382 = happyReduce 8# 84# happyReduction_382+happyReduction_382 (happy_x_8 `HappyStk`+ happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_3 of { happy_var_3 -> + case happyOut37 happy_x_4 of { happy_var_4 -> + case happyOut36 happy_x_6 of { happy_var_6 -> + case happyOut88 happy_x_8 of { happy_var_8 -> + happyIn98+ (For (Left happy_var_3) happy_var_4 (Just happy_var_6) happy_var_8 (happy_var_1 <--> happy_var_8)+ ) `HappyStk` happyRest}}}}}++happyReduce_383 = happyReduce 9# 84# happyReduction_383+happyReduction_383 (happy_x_9 `HappyStk`+ happy_x_8 `HappyStk`+ happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut37 happy_x_3 of { happy_var_3 -> + case happyOut37 happy_x_5 of { happy_var_5 -> + case happyOut36 happy_x_7 of { happy_var_7 -> + case happyOut88 happy_x_9 of { happy_var_9 -> + happyIn98+ (For (Right happy_var_3) happy_var_5 (Just happy_var_7) happy_var_9 (happy_var_1 <--> happy_var_9)+ ) `HappyStk` happyRest}}}}}++happyReduce_384 = happyMonadReduce 8# 84# happyReduction_384+happyReduction_384 (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_2 of { happy_var_2 -> + case happyOut36 happy_x_7 of { happy_var_7 -> + ( unclosed (happy_var_2 <--> happy_var_7) "(")}}+ ) (\r -> happyReturn (happyIn98 r))++happyReduce_385 = happySpecReduce_3 85# happyReduction_385+happyReduction_385 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn99+ (Goto happy_var_2 (happy_var_1 <--> happy_var_3)+ )}}}++happyReduce_386 = happyMonadReduce 2# 85# happyReduction_386+happyReduction_386 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( expected (locOf happy_var_1) ["identifier"])}+ ) (\r -> happyReturn (happyIn99 r))++happyReduce_387 = happyMonadReduce 3# 85# happyReduction_387+happyReduction_387 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut14 happy_x_2 of { happy_var_2 -> + ( expected (locOf happy_var_2) ["';'"])}+ ) (\r -> happyReturn (happyIn99 r))++happyReduce_388 = happySpecReduce_2 85# happyReduction_388+happyReduction_388 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn99+ (Continue (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_389 = happyMonadReduce 2# 85# happyReduction_389+happyReduction_389 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( expected (locOf happy_var_1) ["';'"])}+ ) (\r -> happyReturn (happyIn99 r))++happyReduce_390 = happySpecReduce_2 85# happyReduction_390+happyReduction_390 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn99+ (Break (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_391 = happyMonadReduce 2# 85# happyReduction_391+happyReduction_391 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( expected (locOf happy_var_1) ["';'"])}+ ) (\r -> happyReturn (happyIn99 r))++happyReduce_392 = happySpecReduce_2 85# happyReduction_392+happyReduction_392 happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn99+ (Return Nothing (happy_var_1 <--> happy_var_2)+ )}}++happyReduce_393 = happyMonadReduce 2# 85# happyReduction_393+happyReduction_393 (happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> + ( expected (locOf happy_var_1) ["';'"])}+ ) (\r -> happyReturn (happyIn99 r))++happyReduce_394 = happySpecReduce_3 85# happyReduction_394+happyReduction_394 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_2 of { happy_var_2 -> + case happyOutTok happy_x_3 of { happy_var_3 -> + happyIn99+ (Return (Just happy_var_2) (happy_var_1 <--> happy_var_3)+ )}}}++happyReduce_395 = happyMonadReduce 3# 85# happyReduction_395+happyReduction_395 (happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest) tk+ = happyThen (case happyOut36 happy_x_2 of { happy_var_2 -> + ( expected (locOf happy_var_2) ["';'"])}+ ) (\r -> happyReturn (happyIn99 r))++happyReduce_396 = happySpecReduce_0 86# happyReduction_396+happyReduction_396 = happyIn100+ ([]+ )++happyReduce_397 = happySpecReduce_1 86# happyReduction_397+happyReduction_397 happy_x_1+ = case happyOut101 happy_x_1 of { happy_var_1 -> + happyIn100+ (rev happy_var_1+ )}++happyReduce_398 = happySpecReduce_1 87# happyReduction_398+happyReduction_398 happy_x_1+ = case happyOut102 happy_x_1 of { happy_var_1 -> + happyIn101+ (rsingleton happy_var_1+ )}++happyReduce_399 = happySpecReduce_1 87# happyReduction_399+happyReduction_399 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn101+ (rsingleton (AntiEdecls (getANTI_EDECLS happy_var_1) (locOf happy_var_1))+ )}++happyReduce_400 = happySpecReduce_2 87# happyReduction_400+happyReduction_400 happy_x_2+ happy_x_1+ = case happyOut101 happy_x_1 of { happy_var_1 -> + case happyOut102 happy_x_2 of { happy_var_2 -> + happyIn101+ (rcons happy_var_2 happy_var_1+ )}}++happyReduce_401 = happySpecReduce_2 87# happyReduction_401+happyReduction_401 happy_x_2+ happy_x_1+ = case happyOut101 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn101+ (rcons (AntiEdecls (getANTI_EDECLS happy_var_2) (locOf happy_var_2)) happy_var_1+ )}}++happyReduce_402 = happySpecReduce_1 88# happyReduction_402+happyReduction_402 happy_x_1+ = case happyOut103 happy_x_1 of { happy_var_1 -> + happyIn102+ (FuncDef happy_var_1 (locOf happy_var_1)+ )}++happyReduce_403 = happySpecReduce_1 88# happyReduction_403+happyReduction_403 happy_x_1+ = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn102+ (DecDef happy_var_1 (locOf happy_var_1)+ )}++happyReduce_404 = happySpecReduce_1 88# happyReduction_404+happyReduction_404 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102+ (AntiFunc (getANTI_FUNC happy_var_1) (locOf happy_var_1)+ )}++happyReduce_405 = happySpecReduce_1 88# happyReduction_405+happyReduction_405 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102+ (AntiEsc (getANTI_ESC happy_var_1) (locOf happy_var_1)+ )}++happyReduce_406 = happySpecReduce_1 88# happyReduction_406+happyReduction_406 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn102+ (AntiEdecl (getANTI_EDECL happy_var_1) (locOf happy_var_1)+ )}++happyReduce_407 = happyMonadReduce 3# 89# happyReduction_407+happyReduction_407 (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 happyOut67 happy_x_2 of { happy_var_2 -> + case happyOut90 happy_x_3 of { happy_var_3 -> + ( do{ let (dspec, declRoot) = happy_var_1+ ; let (ident, declToDecl) = happy_var_2+ ; let Block blockItems _ = happy_var_3+ ; let decl = declToDecl declRoot+ ; case decl of+ { Proto protoDecl args _ -> return $+ Func dspec ident protoDecl args+ blockItems+ (decl <--> blockItems)+ ; OldProto protoDecl args _ -> return $+ OldFunc dspec ident protoDecl args Nothing+ blockItems+ (decl <--> blockItems)+ ; _ -> failAt (decl <--> blockItems :: Loc)+ "bad function declaration"+ }+ })}}}+ ) (\r -> happyReturn (happyIn103 r))++happyReduce_408 = happyMonadReduce 4# 89# happyReduction_408+happyReduction_408 (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 happyOut67 happy_x_2 of { happy_var_2 -> + case happyOut95 happy_x_3 of { happy_var_3 -> + case happyOut90 happy_x_4 of { happy_var_4 -> + ( do{ let (dspec, declRoot) = happy_var_1+ ; let (ident, declToDecl) = happy_var_2+ ; let argDecls = happy_var_3+ ; let Block blockItems _ = happy_var_4+ ; let decl = declToDecl declRoot+ ; case decl of+ { OldProto protoDecl args _ -> return $+ OldFunc dspec ident protoDecl args (Just (rev argDecls))+ blockItems+ (decl <--> blockItems)+ ; _ -> failAt (decl <--> blockItems :: Loc)+ "bad function declaration"+ }+ })}}}}+ ) (\r -> happyReturn (happyIn103 r))++happyReduce_409 = happySpecReduce_1 90# happyReduction_409+happyReduction_409 happy_x_1+ = case happyOut105 happy_x_1 of { happy_var_1 -> + happyIn104+ (happy_var_1+ )}++happyReduce_410 = happySpecReduce_2 90# happyReduction_410+happyReduction_410 happy_x_2+ happy_x_1+ = case happyOut104 happy_x_1 of { happy_var_1 -> + case happyOut105 happy_x_2 of { happy_var_2 -> + happyIn104+ (happy_var_1 ++ happy_var_2+ )}}++happyReduce_411 = happyReduce 6# 91# happyReduction_411+happyReduction_411 (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 happyOut106 happy_x_4 of { happy_var_4 -> + happyIn105+ (rev happy_var_4+ ) `HappyStk` happyRest}++happyReduce_412 = happySpecReduce_1 92# happyReduction_412+happyReduction_412 happy_x_1+ = case happyOut107 happy_x_1 of { happy_var_1 -> + happyIn106+ (rsingleton happy_var_1+ )}++happyReduce_413 = happySpecReduce_3 92# happyReduction_413+happyReduction_413 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut106 happy_x_1 of { happy_var_1 -> + case happyOut107 happy_x_3 of { happy_var_3 -> + happyIn106+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_414 = happySpecReduce_1 93# happyReduction_414+happyReduction_414 happy_x_1+ = case happyOut108 happy_x_1 of { happy_var_1 -> + happyIn107+ (Attr happy_var_1 [] (locOf happy_var_1)+ )}++happyReduce_415 = happyReduce 4# 93# happyReduction_415+happyReduction_415 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOut108 happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + happyIn107+ (Attr happy_var_1 (rev happy_var_3) (happy_var_1 <--> happy_var_4)+ ) `HappyStk` happyRest}}}++happyReduce_416 = happySpecReduce_1 94# happyReduction_416+happyReduction_416 happy_x_1+ = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn108+ (happy_var_1+ )}++happyReduce_417 = happySpecReduce_1 94# happyReduction_417+happyReduction_417 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "static" (locOf happy_var_1)+ )}++happyReduce_418 = happySpecReduce_1 94# happyReduction_418+happyReduction_418 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "extern" (locOf happy_var_1)+ )}++happyReduce_419 = happySpecReduce_1 94# happyReduction_419+happyReduction_419 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "register" (locOf happy_var_1)+ )}++happyReduce_420 = happySpecReduce_1 94# happyReduction_420+happyReduction_420 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "typedef" (locOf happy_var_1)+ )}++happyReduce_421 = happySpecReduce_1 94# happyReduction_421+happyReduction_421 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "inline" (locOf happy_var_1)+ )}++happyReduce_422 = happySpecReduce_1 94# happyReduction_422+happyReduction_422 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "auto" (locOf happy_var_1)+ )}++happyReduce_423 = happySpecReduce_1 94# happyReduction_423+happyReduction_423 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "const" (locOf happy_var_1)+ )}++happyReduce_424 = happySpecReduce_1 94# happyReduction_424+happyReduction_424 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "volatile" (locOf happy_var_1)+ )}++happyReduce_425 = happySpecReduce_1 94# happyReduction_425+happyReduction_425 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "unsigned" (locOf happy_var_1)+ )}++happyReduce_426 = happySpecReduce_1 94# happyReduction_426+happyReduction_426 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "long" (locOf happy_var_1)+ )}++happyReduce_427 = happySpecReduce_1 94# happyReduction_427+happyReduction_427 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "short" (locOf happy_var_1)+ )}++happyReduce_428 = happySpecReduce_1 94# happyReduction_428+happyReduction_428 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "signed" (locOf happy_var_1)+ )}++happyReduce_429 = happySpecReduce_1 94# happyReduction_429+happyReduction_429 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "int" (locOf happy_var_1)+ )}++happyReduce_430 = happySpecReduce_1 94# happyReduction_430+happyReduction_430 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "char" (locOf happy_var_1)+ )}++happyReduce_431 = happySpecReduce_1 94# happyReduction_431+happyReduction_431 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "float" (locOf happy_var_1)+ )}++happyReduce_432 = happySpecReduce_1 94# happyReduction_432+happyReduction_432 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "double" (locOf happy_var_1)+ )}++happyReduce_433 = happySpecReduce_1 94# happyReduction_433+happyReduction_433 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn108+ (Id "void" (locOf happy_var_1)+ )}++happyReduce_434 = happySpecReduce_0 95# happyReduction_434+happyReduction_434 = happyIn109+ (False+ )++happyReduce_435 = happySpecReduce_1 95# happyReduction_435+happyReduction_435 happy_x_1+ = happyIn109+ (True+ )++happyReduce_436 = happyReduce 6# 96# happyReduction_436+happyReduction_436 (happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_2 of { happy_var_2 -> + case happyOut111 happy_x_4 of { happy_var_4 -> + case happyOutTok happy_x_5 of { happy_var_5 -> + happyIn110+ (Asm happy_var_2 [] (rev happy_var_4) [] [] [] (happy_var_1 <--> happy_var_5)+ ) `HappyStk` happyRest}}}}++happyReduce_437 = happyReduce 8# 96# happyReduction_437+happyReduction_437 (happy_x_8 `HappyStk`+ happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_2 of { happy_var_2 -> + case happyOut111 happy_x_4 of { happy_var_4 -> + case happyOut112 happy_x_6 of { happy_var_6 -> + case happyOutTok happy_x_7 of { happy_var_7 -> + happyIn110+ (Asm happy_var_2 [] (rev happy_var_4) happy_var_6 [] [] (happy_var_1 <--> happy_var_7)+ ) `HappyStk` happyRest}}}}}++happyReduce_438 = happyReduce 10# 96# happyReduction_438+happyReduction_438 (happy_x_10 `HappyStk`+ happy_x_9 `HappyStk`+ happy_x_8 `HappyStk`+ happy_x_7 `HappyStk`+ happy_x_6 `HappyStk`+ happy_x_5 `HappyStk`+ happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_2 of { happy_var_2 -> + case happyOut111 happy_x_4 of { happy_var_4 -> + case happyOut112 happy_x_6 of { happy_var_6 -> + case happyOut112 happy_x_8 of { happy_var_8 -> + case happyOutTok happy_x_9 of { happy_var_9 -> + happyIn110+ (Asm happy_var_2 [] (rev happy_var_4) happy_var_6 happy_var_8 [] (happy_var_1 <--> happy_var_9)+ ) `HappyStk` happyRest}}}}}}++happyReduce_439 = happyReduce 12# 96# happyReduction_439+happyReduction_439 (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)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_2 of { happy_var_2 -> + case happyOut111 happy_x_4 of { happy_var_4 -> + case happyOut112 happy_x_6 of { happy_var_6 -> + case happyOut112 happy_x_8 of { happy_var_8 -> + case happyOut115 happy_x_10 of { happy_var_10 -> + case happyOutTok happy_x_11 of { happy_var_11 -> + happyIn110+ (Asm happy_var_2 [] (rev happy_var_4) happy_var_6 happy_var_8 happy_var_10 (happy_var_1 <--> happy_var_11)+ ) `HappyStk` happyRest}}}}}}}++happyReduce_440 = happySpecReduce_1 97# happyReduction_440+happyReduction_440 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn111+ (rsingleton ((fst . getSTRING) happy_var_1)+ )}++happyReduce_441 = happySpecReduce_2 97# happyReduction_441+happyReduction_441 happy_x_2+ happy_x_1+ = case happyOut111 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { happy_var_2 -> + happyIn111+ (rcons ((fst . getSTRING) happy_var_2) happy_var_1+ )}}++happyReduce_442 = happySpecReduce_0 98# happyReduction_442+happyReduction_442 = happyIn112+ ([]+ )++happyReduce_443 = happySpecReduce_1 98# happyReduction_443+happyReduction_443 happy_x_1+ = case happyOut113 happy_x_1 of { happy_var_1 -> + happyIn112+ (rev happy_var_1+ )}++happyReduce_444 = happySpecReduce_1 99# happyReduction_444+happyReduction_444 happy_x_1+ = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn113+ (rsingleton happy_var_1+ )}++happyReduce_445 = happySpecReduce_3 99# happyReduction_445+happyReduction_445 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut113 happy_x_1 of { happy_var_1 -> + case happyOut114 happy_x_3 of { happy_var_3 -> + happyIn113+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_446 = happyReduce 4# 100# happyReduction_446+happyReduction_446 (happy_x_4 `HappyStk`+ happy_x_3 `HappyStk`+ happy_x_2 `HappyStk`+ happy_x_1 `HappyStk`+ happyRest)+ = case happyOutTok happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + happyIn114+ (((fst . getSTRING) happy_var_1, happy_var_3)+ ) `HappyStk` happyRest}}++happyReduce_447 = happySpecReduce_0 101# happyReduction_447+happyReduction_447 = happyIn115+ ([]+ )++happyReduce_448 = happySpecReduce_1 101# happyReduction_448+happyReduction_448 happy_x_1+ = case happyOut116 happy_x_1 of { happy_var_1 -> + happyIn115+ (rev happy_var_1+ )}++happyReduce_449 = happySpecReduce_1 102# happyReduction_449+happyReduction_449 happy_x_1+ = case happyOut117 happy_x_1 of { happy_var_1 -> + happyIn116+ (rsingleton happy_var_1+ )}++happyReduce_450 = happySpecReduce_3 102# happyReduction_450+happyReduction_450 happy_x_3+ happy_x_2+ happy_x_1+ = case happyOut116 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + happyIn116+ (rcons happy_var_3 happy_var_1+ )}}++happyReduce_451 = happySpecReduce_1 103# happyReduction_451+happyReduction_451 happy_x_1+ = case happyOutTok happy_x_1 of { happy_var_1 -> + happyIn117+ ((fst . getSTRING) happy_var_1+ )}++happyNewToken action sts stk+ = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in+ case tk of {+ L _ T.Teof -> happyDoAction 139# tk action sts stk;+ L _ (T.TcharConst _) -> cont 1#;+ L _ (T.TstringConst _) -> cont 2#;+ L _ (T.TintConst _) -> cont 3#;+ L _ (T.TlongIntConst _) -> cont 4#;+ L _ (T.TlongLongIntConst _) -> cont 5#;+ L _ (T.TfloatConst _) -> cont 6#;+ L _ (T.TdoubleConst _) -> cont 7#;+ L _ (T.TlongDoubleConst _) -> cont 8#;+ L _ (T.Tidentifier _) -> cont 9#;+ L _ (T.Tnamed _) -> cont 10#;+ L _ T.Tlparen -> cont 11#;+ L _ T.Trparen -> cont 12#;+ L _ T.Tlbrack -> cont 13#;+ L _ T.Trbrack -> cont 14#;+ L _ T.Tlbrace -> cont 15#;+ L _ T.Trbrace -> cont 16#;+ L _ T.Tcomma -> cont 17#;+ L _ T.Tsemi -> cont 18#;+ L _ T.Tcolon -> cont 19#;+ L _ T.Tquestion -> cont 20#;+ L _ T.Tdot -> cont 21#;+ L _ T.Tarrow -> cont 22#;+ L _ T.Tellipses -> cont 23#;+ L _ T.Tplus -> cont 24#;+ L _ T.Tminus -> cont 25#;+ L _ T.Tstar -> cont 26#;+ L _ T.Tdiv -> cont 27#;+ L _ T.Tmod -> cont 28#;+ L _ T.Tnot -> cont 29#;+ L _ T.Tand -> cont 30#;+ L _ T.Tor -> cont 31#;+ L _ T.Txor -> cont 32#;+ L _ T.Tlsh -> cont 33#;+ L _ T.Trsh -> cont 34#;+ L _ T.Tinc -> cont 35#;+ L _ T.Tdec -> cont 36#;+ L _ T.Tlnot -> cont 37#;+ L _ T.Tland -> cont 38#;+ L _ T.Tlor -> cont 39#;+ L _ T.Teq -> cont 40#;+ L _ T.Tne -> cont 41#;+ L _ T.Tlt -> cont 42#;+ L _ T.Tgt -> cont 43#;+ L _ T.Tle -> cont 44#;+ L _ T.Tge -> cont 45#;+ L _ T.Tassign -> cont 46#;+ L _ T.Tadd_assign -> cont 47#;+ L _ T.Tsub_assign -> cont 48#;+ L _ T.Tmul_assign -> cont 49#;+ L _ T.Tdiv_assign -> cont 50#;+ L _ T.Tmod_assign -> cont 51#;+ L _ T.Tlsh_assign -> cont 52#;+ L _ T.Trsh_assign -> cont 53#;+ L _ T.Tand_assign -> cont 54#;+ L _ T.Tor_assign -> cont 55#;+ L _ T.Txor_assign -> cont 56#;+ L _ T.Tauto -> cont 57#;+ L _ T.Tbreak -> cont 58#;+ L _ T.Tcase -> cont 59#;+ L _ T.Tchar -> cont 60#;+ L _ T.Tconst -> cont 61#;+ L _ T.Tcontinue -> cont 62#;+ L _ T.Tdefault -> cont 63#;+ L _ T.Tdo -> cont 64#;+ L _ T.Tdouble -> cont 65#;+ L _ T.Telse -> cont 66#;+ L _ T.Tenum -> cont 67#;+ L _ T.Textern -> cont 68#;+ L _ T.Tfloat -> cont 69#;+ L _ T.Tfor -> cont 70#;+ L _ T.Tgoto -> cont 71#;+ L _ T.Tif -> cont 72#;+ L _ T.Tinline -> cont 73#;+ L _ T.Tint -> cont 74#;+ L _ T.Tlong -> cont 75#;+ L _ T.Tregister -> cont 76#;+ L _ T.Trestrict -> cont 77#;+ L _ T.Treturn -> cont 78#;+ L _ T.Tshort -> cont 79#;+ L _ T.Tsigned -> cont 80#;+ L _ T.Tsizeof -> cont 81#;+ L _ T.Tstatic -> cont 82#;+ L _ T.Tstruct -> cont 83#;+ L _ T.Tswitch -> cont 84#;+ L _ T.Ttypedef -> cont 85#;+ L _ T.Tunion -> cont 86#;+ L _ T.Tunsigned -> cont 87#;+ L _ T.Tvoid -> cont 88#;+ L _ T.Tvolatile -> cont 89#;+ L _ T.Twhile -> cont 90#;+ L _ T.TBool -> cont 91#;+ L _ T.TComplex -> cont 92#;+ L _ T.TImaginary -> cont 93#;+ L _ T.Tasm -> cont 94#;+ L _ T.Tattribute -> cont 95#;+ L _ T.Textension -> cont 96#;+ L _ T.Tbuiltin_va_arg -> cont 97#;+ L _ T.Tbuiltin_va_list -> cont 98#;+ L _ T.Ttypeof -> cont 99#;+ L _ T.T3lt -> cont 100#;+ L _ T.T3gt -> cont 101#;+ L _ T.Tdevice -> cont 102#;+ L _ T.Tglobal -> cont 103#;+ L _ T.Thost -> cont 104#;+ L _ T.Tconstant -> cont 105#;+ L _ T.Tshared -> cont 106#;+ L _ T.Tnoinline -> cont 107#;+ L _ T.Ttypename -> cont 108#;+ L _ (T.Tanti_id _) -> cont 109#;+ L _ (T.Tanti_int _) -> cont 110#;+ L _ (T.Tanti_uint _) -> cont 111#;+ L _ (T.Tanti_lint _) -> cont 112#;+ L _ (T.Tanti_ulint _) -> cont 113#;+ L _ (T.Tanti_float _) -> cont 114#;+ L _ (T.Tanti_double _) -> cont 115#;+ L _ (T.Tanti_long_double _) -> cont 116#;+ L _ (T.Tanti_char _) -> cont 117#;+ L _ (T.Tanti_string _) -> cont 118#;+ L _ (T.Tanti_exp _) -> cont 119#;+ L _ (T.Tanti_func _) -> cont 120#;+ L _ (T.Tanti_args _) -> cont 121#;+ L _ (T.Tanti_decl _) -> cont 122#;+ L _ (T.Tanti_decls _) -> cont 123#;+ L _ (T.Tanti_sdecl _) -> cont 124#;+ L _ (T.Tanti_sdecls _) -> cont 125#;+ L _ (T.Tanti_enum _) -> cont 126#;+ L _ (T.Tanti_enums _) -> cont 127#;+ L _ (T.Tanti_esc _) -> cont 128#;+ L _ (T.Tanti_edecl _) -> cont 129#;+ L _ (T.Tanti_edecls _) -> cont 130#;+ L _ (T.Tanti_item _) -> cont 131#;+ L _ (T.Tanti_items _) -> cont 132#;+ L _ (T.Tanti_stm _) -> cont 133#;+ L _ (T.Tanti_stms _) -> cont 134#;+ L _ (T.Tanti_spec _) -> cont 135#;+ L _ (T.Tanti_type _) -> cont 136#;+ L _ (T.Tanti_param _) -> cont 137#;+ L _ (T.Tanti_params _) -> cont 138#;+ _ -> 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' :: () => ((L T.Token)) -> P a+happyError' tk = happyError tk++parseExp = happySomeParser where+ happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut36 x))++parseEdecl = happySomeParser where+ happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut102 x))++parseDecl = happySomeParser where+ happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut39 x))++parseStructDecl = happySomeParser where+ happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut54 x))++parseEnum = happySomeParser where+ happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (happyOut61 x))++parseType = happySomeParser where+ happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (happyOut77 x))++parseParam = happySomeParser where+ happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (happyOut76 x))++parseInit = happySomeParser where+ happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (happyOut83 x))++parseStm = happySomeParser where+ happySomeParser = happyThen (happyParse 8#) (\x -> happyReturn (happyOut88 x))++parseUnit = happySomeParser where+ happySomeParser = happyThen (happyParse 9#) (\x -> happyReturn (happyOut100 x))++parseFunc = happySomeParser where+ happySomeParser = happyThen (happyParse 10#) (\x -> happyReturn (happyOut103 x))++happySeq = happyDontSeq+++happyError :: L T.Token -> P a+happyError (L (Loc start _) _) =+ throw $ ParserException (Loc start start) (text "parse error")++getCHAR (L _ (T.TcharConst x)) = x+getSTRING (L _ (T.TstringConst x)) = x+getINT (L _ (T.TintConst x)) = x+getLONG (L _ (T.TlongIntConst x)) = x+getLONG_LONG (L _ (T.TlongLongIntConst x)) = x+getFLOAT (L _ (T.TfloatConst x)) = x+getDOUBLE (L _ (T.TdoubleConst x)) = x+getLONG_DOUBLE (L _ (T.TlongDoubleConst x)) = x+getID (L _ (T.Tidentifier id)) = id+getNAMED (L _ (T.Tnamed id)) = id++getANTI_ID (L _ (T.Tanti_id v)) = v+getANTI_INT (L _ (T.Tanti_int v)) = v+getANTI_UINT (L _ (T.Tanti_uint v)) = v+getANTI_LINT (L _ (T.Tanti_lint v)) = v+getANTI_ULINT (L _ (T.Tanti_ulint v)) = v+getANTI_FLOAT (L _ (T.Tanti_float v)) = v+getANTI_DOUBLE (L _ (T.Tanti_double v)) = v+getANTI_LONG_DOUBLE (L _ (T.Tanti_long_double v)) = v+getANTI_CHAR (L _ (T.Tanti_char v)) = v+getANTI_STRING (L _ (T.Tanti_string v)) = v+getANTI_EXP (L _ (T.Tanti_exp v)) = v+getANTI_FUNC (L _ (T.Tanti_func v)) = v+getANTI_ARGS (L _ (T.Tanti_args v)) = v+getANTI_DECL (L _ (T.Tanti_decl v)) = v+getANTI_DECLS (L _ (T.Tanti_decls v)) = v+getANTI_SDECL (L _ (T.Tanti_sdecl v)) = v+getANTI_SDECLS (L _ (T.Tanti_sdecls v)) = v+getANTI_ENUM (L _ (T.Tanti_enum v)) = v+getANTI_ENUMS (L _ (T.Tanti_enums v)) = v+getANTI_ESC (L _ (T.Tanti_esc v)) = v+getANTI_EDECL (L _ (T.Tanti_edecl v)) = v+getANTI_EDECLS (L _ (T.Tanti_edecls v)) = v+getANTI_ITEM (L _ (T.Tanti_item v)) = v+getANTI_ITEMS (L _ (T.Tanti_items v)) = v+getANTI_STM (L _ (T.Tanti_stm v)) = v+getANTI_STMS (L _ (T.Tanti_stms v)) = v+getANTI_TYPE (L _ (T.Tanti_type v)) = v+getANTI_SPEC (L _ (T.Tanti_spec v)) = v+getANTI_PARAM (L _ (T.Tanti_param v)) = v+getANTI_PARAMS (L _ (T.Tanti_params v)) = v++lexer :: (L T.Token -> P a) -> P a+lexer cont = do+ tok <- lexToken+ cont tok++locate :: Loc -> (SrcLoc -> a) -> L a+locate loc f = L loc (f (SrcLoc loc))++data DeclTySpec = DeclTySpec DeclSpec !SrcLoc+ | AntiDeclTySpec String !SrcLoc++data TySpec = TSauto !SrcLoc+ | TSregister !SrcLoc+ | TSstatic !SrcLoc+ | TSextern !SrcLoc+ | TSexternL String !SrcLoc+ | TStypedef !SrcLoc++ | TSconst !SrcLoc+ | TSvolatile !SrcLoc+ | TSinline !SrcLoc++ | TSsigned !SrcLoc+ | TSunsigned !SrcLoc++ | TSvoid !SrcLoc+ | TSchar !SrcLoc+ | TSshort !SrcLoc+ | TSint !SrcLoc+ | TSlong !SrcLoc+ | TSfloat !SrcLoc+ | TSdouble !SrcLoc++ | TSstruct (Maybe Id) (Maybe [FieldGroup]) [Attr] !SrcLoc+ | TSunion (Maybe Id) (Maybe [FieldGroup]) [Attr] !SrcLoc+ | TSenum (Maybe Id) [CEnum] [Attr] !SrcLoc+ | TSnamed Id !SrcLoc++ | TStypeofExp Exp !SrcLoc+ | TStypeofType Type !SrcLoc+ | TSva_list !SrcLoc++ -- C99+ | TSrestrict !SrcLoc++ -- CUDA+ | TSdevice !SrcLoc+ | TSglobal !SrcLoc+ | TShost !SrcLoc+ | TSconstant !SrcLoc+ | TSshared !SrcLoc+ | TSnoinline !SrcLoc++instance Located DeclTySpec where+ getLoc (DeclTySpec _ loc) = getLoc loc+ getLoc (AntiDeclTySpec _ loc) = getLoc loc++instance Located TySpec where+ getLoc (TSauto loc) = getLoc loc+ getLoc (TSregister loc) = getLoc loc+ getLoc (TSstatic loc) = getLoc loc+ getLoc (TSextern loc) = getLoc loc+ getLoc (TSexternL _ loc) = getLoc loc+ getLoc (TStypedef loc) = getLoc loc++ getLoc (TSconst loc) = getLoc loc+ getLoc (TSvolatile loc) = getLoc loc+ getLoc (TSinline loc) = getLoc loc++ getLoc (TSsigned loc) = getLoc loc+ getLoc (TSunsigned loc) = getLoc loc++ getLoc (TSvoid loc) = getLoc loc+ getLoc (TSchar loc) = getLoc loc+ getLoc (TSshort loc) = getLoc loc+ getLoc (TSint loc) = getLoc loc+ getLoc (TSlong loc) = getLoc loc+ getLoc (TSfloat loc) = getLoc loc+ getLoc (TSdouble loc) = getLoc loc++ getLoc (TSstruct _ _ _ loc) = getLoc loc+ getLoc (TSunion _ _ _ loc) = getLoc loc+ getLoc (TSenum _ _ _ loc) = getLoc loc+ getLoc (TSnamed _ loc) = getLoc loc++ getLoc (TStypeofExp _ loc) = getLoc loc+ getLoc (TStypeofType _ loc) = getLoc loc+ getLoc (TSva_list loc) = getLoc loc++ getLoc (TSrestrict loc) = getLoc loc++ getLoc (TSdevice loc) = getLoc loc+ getLoc (TSglobal loc) = getLoc loc+ getLoc (TShost loc) = getLoc loc+ getLoc (TSconstant loc) = getLoc loc+ getLoc (TSshared loc) = getLoc loc+ getLoc (TSnoinline loc) = getLoc loc++instance Pretty TySpec where+ ppr (TSauto _) = text "auto"+ ppr (TSregister _) = text "register"+ ppr (TSstatic _) = text "static"+ ppr (TSextern _) = text "extern"+ ppr (TSexternL l _) = text "extern" <+> ppr l+ ppr (TStypedef _) = text "typedef"++ ppr (TSconst _) = text "const"+ ppr (TSinline _) = text "inline"+ ppr (TSrestrict _) = text "restrict"+ ppr (TSvolatile _) = text "volatile"++ ppr (TSsigned _) = text "signed"+ ppr (TSunsigned _) = text "unsigned"++ ppr (TSvoid _) = text "void"+ ppr (TSchar _) = text "char"+ ppr (TSshort _) = text "short"+ ppr (TSint _) = text "int"+ ppr (TSlong _) = text "long"+ ppr (TSfloat _) = text "float"+ ppr (TSdouble _) = text "double"++ ppr (TSstruct maybe_id maybe_fields attrs _) =+ pprStructOrUnion "struct" maybe_id maybe_fields attrs++ ppr (TSunion maybe_id maybe_fields attrs _) =+ pprStructOrUnion "union" maybe_id maybe_fields attrs++ ppr (TSenum maybe_id cenums attrs _) =+ pprEnum maybe_id cenums attrs++ ppr (TStypeofExp e _) = text "__typeof__" <> parens (ppr e)+ ppr (TStypeofType ty _) = text "__typeof__" <> parens (ppr ty)+ ppr (TSnamed ident _) = ppr ident++ ppr (TSva_list _) = text "__builtin_va_list"++ ppr (TSdevice _) = text "__device__"+ ppr (TSglobal _) = text "__global__"+ ppr (TShost _) = text "__host__"+ ppr (TSconstant _) = text "__constant__"+ ppr (TSshared _) = text "__shared__"+ ppr (TSnoinline _) = text "__noinline__"++isStorage :: TySpec -> Bool+isStorage (TSauto _) = True+isStorage (TSregister _) = True+isStorage (TSstatic _) = True+isStorage (TSextern _) = True+isStorage (TSexternL _ _) = True+isStorage (TStypedef _) = True+isStorage _ = False++mkStorage :: [TySpec] -> [Storage]+mkStorage specs = map mk (filter isStorage specs)+ where+ mk :: TySpec -> Storage+ mk (TSauto loc) = Tauto loc+ mk (TSregister loc) = Tregister loc+ mk (TSstatic loc) = Tstatic loc+ mk (TSextern loc) = Textern loc+ mk (TSexternL l loc) = TexternL l loc+ mk (TStypedef loc) = Ttypedef loc+ mk _ = error "internal error in mkStorage"++isTypeQual :: TySpec -> Bool+isTypeQual (TSconst _) = True+isTypeQual (TSvolatile _) = True+isTypeQual (TSinline _) = True+isTypeQual (TSrestrict _) = True+isTypeQual (TSdevice _) = True+isTypeQual (TSglobal _) = True+isTypeQual (TShost _) = True+isTypeQual (TSconstant _) = True+isTypeQual (TSshared _) = True+isTypeQual (TSnoinline _) = True+isTypeQual _ = False++mkTypeQuals :: [TySpec] -> [TypeQual]+mkTypeQuals specs = map mk (filter isTypeQual specs)+ where+ mk :: TySpec -> TypeQual+ mk (TSconst loc) = Tconst loc+ mk (TSvolatile loc) = Tvolatile loc+ mk (TSinline loc) = Tinline loc+ mk (TSrestrict loc) = Trestrict loc+ mk (TSdevice loc) = Tdevice loc+ mk (TSglobal loc) = Tglobal loc+ mk (TShost loc) = Thost loc+ mk (TSconstant loc) = Tconstant loc+ mk (TSshared loc) = Tshared loc+ mk (TSnoinline loc) = Tnoinline loc+ mk _ = error "internal error in mkTypeQual"++isSign :: TySpec -> Bool+isSign (TSsigned _) = True+isSign (TSunsigned _) = True+isSign _ = False++hasSign :: [TySpec] -> Bool+hasSign specs = any isSign specs++mkSign :: [TySpec] -> P (Maybe Sign)+mkSign specs =+ case filter isSign specs of+ [] -> return Nothing+ [TSunsigned loc] -> return (Just (Tunsigned loc))+ [TSsigned loc] -> return (Just (Tsigned loc))+ [_] -> fail "internal error in mkSign"+ _ -> fail "multiple signs specified"++checkNoSign :: [TySpec] -> String -> P ()+checkNoSign spec msg | hasSign spec = fail msg+ | otherwise = return ()++composeDecls :: Decl -> Decl -> Decl+composeDecls (DeclRoot _) root =+ root++composeDecls (C.Ptr quals decl loc) root =+ C.Ptr quals (composeDecls decl root) loc++composeDecls (Array quals size decl loc) root =+ Array quals size (composeDecls decl root) loc++composeDecls (Proto decl args loc) root =+ Proto (composeDecls decl root) args loc++composeDecls (OldProto decl args loc) root =+ OldProto (composeDecls decl root) args loc++mkDeclSpec :: [TySpec] -> P DeclSpec+mkDeclSpec specs =+ go rest+ where+ storage ::[Storage]+ storage = mkStorage specs++ quals :: [TypeQual]+ quals = mkTypeQuals specs++ rest :: [TySpec]+ rest = [x | x <- specs+ , not (isStorage x) && not (isTypeQual x) && not (isSign x)]++ go :: [TySpec] -> P DeclSpec+ go [TSvoid loc] = do+ checkNoSign specs "sign specified for void type"+ return $ cdeclSpec storage quals (Tvoid loc)++ go [TSchar loc] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tchar sign loc)++ go [TSshort loc] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tshort sign loc)++ go [TSshort _, TSint _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tshort sign (locOf rest))++ go [TSint _, TSshort _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tshort sign (locOf rest))++ go [TSint loc] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tint sign loc)++ go [TSlong loc] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong sign loc)++ go [TSlong _, TSint _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong sign (locOf rest))++ go [TSint _, TSlong _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong sign (locOf rest))++ go [TSlong _, TSlong _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong_long sign (locOf rest))++ go [TSlong _, TSlong _, TSint _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong_long sign (locOf rest))++ go [TSlong _, TSint _, TSlong _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong_long sign (locOf rest))++ go [TSint _, TSlong _, TSlong _] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tlong_long sign (locOf rest))++ go [TSfloat loc] = do+ checkNoSign specs "sign specified for float type"+ return $ cdeclSpec storage quals (Tfloat loc)++ go [TSdouble loc] = do+ checkNoSign specs "sign specified for double type"+ return $ cdeclSpec storage quals (Tdouble loc)++ go [TSlong _, TSdouble _] = do+ checkNoSign specs "sign specified for long double type"+ return $ cdeclSpec storage quals (Tlong_double (locOf rest))++ go [TSdouble _, TSlong _] = do+ checkNoSign specs "sign specified for long double type"+ return $ cdeclSpec storage quals (Tlong_double (locOf rest))++ go [TSstruct ident fields attrs loc] = do+ checkNoSign specs "sign specified for struct type"+ return $ cdeclSpec storage quals (Tstruct ident fields attrs loc)++ go [TSunion ident fields attrs loc] = do+ checkNoSign specs "sign specified for union type"+ return $ cdeclSpec storage quals (Tunion ident fields attrs loc)++ go [TSenum ident enums attrs loc] = do+ checkNoSign specs "sign specified for enum type"+ return $ cdeclSpec storage quals (Tenum ident enums attrs loc)++ go [TSnamed ident loc] = do+ checkNoSign specs "sign specified for named type"+ return $ cdeclSpec storage quals (Tnamed ident loc)++ go [TStypeofExp e loc] = do+ checkNoSign specs "sign specified for typeof"+ return $ cdeclSpec storage quals (TtypeofExp e loc)++ go [TStypeofType ty loc] = do+ checkNoSign specs "sign specified for typeof"+ return $ cdeclSpec storage quals (TtypeofType ty loc)++ go [TSva_list loc] = do+ checkNoSign specs "sign specified for __builtin_va_list"+ return $ cdeclSpec storage quals (Tva_list loc)++ go [] = do+ sign <- mkSign specs+ return $ cdeclSpec storage quals (Tint sign (storage <--> quals))++ go tyspecs =+ throw $ ParserException loc+ (text "bad type:" <+> spread (map ppr tyspecs))+ where+ loc = getLoc tyspecs++mkPtr :: [TySpec] -> Decl -> Decl+mkPtr specs decl = C.Ptr quals decl (specs <--> decl)+ where+ quals = mkTypeQuals specs++mkArray :: [TySpec] -> ArraySize -> Decl -> Decl+mkArray specs size decl = Array quals size decl (specs <--> decl)+ where+ quals = mkTypeQuals specs++mkProto :: Params -> Decl -> Decl+mkProto args decl = Proto decl args (args <--> decl)++mkOldProto :: [Id] -> Decl -> Decl+mkOldProto args decl = OldProto decl args (args <--> decl)++checkInitGroup :: DeclSpec -> Decl -> [Attr] -> [Init] -> P InitGroup+checkInitGroup dspec decl attrs inits =+ go dspec+ where+ go :: DeclSpec -> P InitGroup+ go (DeclSpec storage quals tspec _) | any isTypedef storage = do+ typedefs <- mapM checkInit inits'+ let dspec' = cdeclSpec storage' quals tspec+ return $ ctypedefGroup dspec' attrs typedefs+ where+ storage' :: [Storage]+ storage' = [x | x <- storage, (not . isTypedef) x]++ isTypedef :: Storage -> Bool+ isTypedef (Ttypedef _) = True+ isTypedef _ = False++ checkInit :: Init -> P Typedef+ checkInit init@(Init ident _ _ (Just _) _ _)=+ throw $ ParserException (getLoc init) $+ text "typedef" <+>+ squotes (ppr ident) <+>+ text "is illegaly initialized"++ checkInit (Init ident@(Id name _) decl _ _ attrs _) = do+ addTypedef name+ return $ ctypedef ident decl attrs++ checkInit (Init ident@(AntiId _ _) decl _ _ attrs _) =+ return $ ctypedef ident decl attrs++ go _ = do+ mapM_ checkInit inits'+ return $ cinitGroup dspec attrs inits'+ where+ checkInit :: Init -> P ()+ checkInit (Init (Id name _) _ _ _ _ _) = addVariable name+ checkInit (Init (AntiId _ _) _ _ _ _ _) = return ()++ composeInitDecl :: Decl -> Init -> Init+ composeInitDecl decl (Init ident initDecl maybe_asmlabel maybe_exp attrs loc) =+ Init ident (composeDecls initDecl decl) maybe_asmlabel maybe_exp attrs loc++ inits' = map (composeInitDecl decl) inits++ loc :: Loc+ loc = (dspec <--> attrs :: Loc) <--> inits++declRoot :: Located a => a -> Decl+declRoot x = DeclRoot (locOf x)++data RevList a = RNil+ | RCons a (RevList a)++rnil :: RevList a+rnil = RNil++rsingleton :: a -> RevList a+rsingleton x = RCons x RNil++rcons :: a -> RevList a -> RevList a+rcons x xs = RCons x xs++rev :: RevList a -> [a]+rev xs = go [] xs+ where+ go l RNil = l+ go l (RCons x xs) = go (x : l) xs++expected :: Loc+ -> [String]+ -> P a+expected loc alts =+ throw $ ParserException (locEnd loc)+ (text "unclosed" <+> go alts)+ where+ go :: [String] -> Doc+ go [] = empty+ go [x] = text x+ go [x, y] = text x <+> text "or" <+> text y+ go (x : xs) = text x <> comma <+> go xs++unclosed :: Loc+ -> String+ -> P a+unclosed loc x =+ throw $ ParserException (locEnd loc)+ (text "unclosed" <+> squotes (text x))++badExecutionContext :: Loc+ -> [Exp]+ -> P a+badExecutionContext loc es =+ throw $ ParserException (locEnd loc) $+ text "execution context should have 2-4 arguments, but saw" <+>+ ppr (length es)++badFunctionDeclaration :: Loc+ -> [Exp]+ -> P a+badFunctionDeclaration loc es =+ throw $ ParserException (locEnd loc) $+ text "execution context should have 2-4 arguments, but saw" <+>+ ppr (length es)+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "<built-in>" #-}+{-# LINE 1 "<command-line>" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp ++{-# LINE 30 "templates/GenericTemplate.hs" #-}+++data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList++++++{-# LINE 51 "templates/GenericTemplate.hs" #-}++{-# LINE 61 "templates/GenericTemplate.hs" #-}++{-# LINE 70 "templates/GenericTemplate.hs" #-}++infixr 9 `HappyStk`+data HappyStk a = HappyStk a (HappyStk a)++-----------------------------------------------------------------------------+-- starting the parse++happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll++-----------------------------------------------------------------------------+-- Accepting the parse++-- If the current token is 0#, it means we've just accepted a partial+-- parse (a %partial parser). We must ignore the saved token on the top of+-- the stack in this case.+happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =+ happyReturn1 ans+happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j (happyTcHack st)) (happyReturn1 ans)++-----------------------------------------------------------------------------+-- Arrays only: do the next action++++happyDoAction i tk st+ = {- nothing -}+++ case action of+ 0# -> {- nothing -}+ happyFail i tk st+ -1# -> {- nothing -}+ happyAccept i tk st+ n | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}++ (happyReduceArr Happy_Data_Array.! rule) i tk st+ where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))+ n -> {- nothing -}+++ happyShift new_state i tk st+ where !(new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))+ where !(off) = indexShortOffAddr happyActOffsets st+ !(off_i) = (off Happy_GHC_Exts.+# i)+ check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#))+ then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# i)+ else False+ !(action)+ | check = indexShortOffAddr happyTable off_i+ | otherwise = indexShortOffAddr happyDefActions st++{-# LINE 130 "templates/GenericTemplate.hs" #-}+++indexShortOffAddr (HappyA# arr) off =+ Happy_GHC_Exts.narrow16Int# i+ where+ !i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)+ !high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))+ !low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))+ !off' = off Happy_GHC_Exts.*# 2#++++++data HappyAddr = HappyA# Happy_GHC_Exts.Addr#+++++-----------------------------------------------------------------------------+-- HappyState data type (not arrays)++{-# LINE 163 "templates/GenericTemplate.hs" #-}++-----------------------------------------------------------------------------+-- Shifting a token++happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =+ let !(i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.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 Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.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 Happy_GHC_Exts.+# nt)+ !(new_state) = indexShortOffAddr happyTable off_i+++++happyDrop 0# l = l+happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t++happyDropStk 0# l = l+happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.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 Happy_GHC_Exts.+# 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 ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)++-- Internal happy errors:++notHappyAtAll = error "Internal Happy error\n"++-----------------------------------------------------------------------------+-- Hack to get the typechecker to accept our action functions+++happyTcHack :: Happy_GHC_Exts.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.
+ language-c-quote.cabal view
@@ -0,0 +1,73 @@+name: language-c-quote+version: 0.2+cabal-version: >= 1.8+license: BSD3+license-file: LICENSE+copyright: (c) 2006-2010 Harvard University+author: Geoffrey Mainland <mainland@eecs.harvard.edu>+maintainer: mainland@eecs.harvard.edu+stability: alpha+homepage: http://www.eecs.harvard.edu/~mainland/+category: Language+synopsis: C/CUDA quasiquoting library.+description: C/CUDA quasiquoting library.++build-type: Custom++flag tests+ description: Build test programs.+ default: False++library+ build-depends:+ array >=0.3 && <0.4,+ base >=4 && <5,+ bytestring >=0.9 && <0.10,+ containers >=0.2 && <0.4,+ exception-mtl >=0.1 && <0.2,+ filepath >=1.1 && <1.2,+ srcloc >=0.1 && <0.2,+ mainland-pretty >=0.1 && <0.2,+ mtl >=1.1 && <1.2,+ syb >=0.1 && <0.2,+ symbol >=0.1 && <0.2,+ template-haskell >=2.3 && <2.5++ if impl(ghc >= 6.10 && < 6.12)+ build-depends:+ haskell-src-meta >= 0.0 && < 0.1++ if impl(ghc >= 6.12 && < 6.13)+ build-depends:+ haskell-src-meta >= 0.1 && < 0.2++ exposed-modules:+ Language.C+ Language.C.Parser+ Language.C.Parser.Lexer+ Language.C.Parser.Monad+ Language.C.Parser.Parser+ Language.C.Parser.Tokens+ Language.C.Pretty+ Language.C.Quote.Base+ Language.C.Quote.C+ Language.C.Quote.CUDA+ Language.C.Quote.GCC+ Language.C.Smart+ Language.C.Syntax++executable unit-test+ build-depends:+ HUnit >=1.2 && <1.3,+ base>=4 && <5,+ language-c-quote >=0.2 && <0.3++ main-is: Main.hs+ hs-source-dirs: tests/unit++ if !flag(tests)+ buildable: False++source-repository head+ type: svn+ location: http://senseless.eecs.harvard.edu/repos/mainland-projects/language-c-quote/trunk/
+ tests/unit/Main.hs view
@@ -0,0 +1,141 @@+{-# LANGUAGE QuasiQuotes #-}++module Main where++import Test.HUnit++import Language.C.Quote.C+import qualified Language.C.Syntax++main = runTestTT tests++tests = TestList [exp_id, exp_int, exp_float, exp_char, exp_string,+ exp_exp, exp_func, exp_args, exp_decl, exp_sdecl,+ exp_enum, exp_edecl, exp_stm, exp_param, exp_ty,+ pat_args]+++exp_id = "exp id" ~: [$cexp|$id:ident|] ~?= [$cexp|x|]+ where+ ident = "x"++exp_int =+ "exp int" ~: [$cexp|$int:one + $uint:one + $lint:one + $ulint:one|]+ ~?= [$cexp|1 + 1U + 1L + 1UL|]+ where+ one = 1++exp_float =+ "exp float" ~: [$cexp|$float:one + $double:one + $ldouble:one|]+ ~?= [$cexp|1.0F + 1.0 + 1.0L|]+ where+ one = 1++exp_char = "exp char" ~: [$cexp|$char:a|] ~?= [$cexp|'a'|]+ where+ a = 'a'++exp_string =+ "exp string" ~: [$cexp|$string:hello|] ~?= [$cexp|"Hello, world\n"|]+ where+ hello = "Hello, world\n"++exp_exp =+ "exp expression" ~: [$cexp|$exp:e1 + $exp:e2|] ~?= [$cexp|1 + 2|]+ where+ e1 = [$cexp|1|]+ e2 = [$cexp|2|]++exp_func =+ "exp function" ~: [$cunit|$func:f|]+ ~?= [$cunit|int add(int x) { return x + 10; }|]+ where+ f = add 10+ add n = [$cfun|int add(int x) { return x + $int:n; } |]++exp_args =+ "exp args" ~: [$cstm|f($exp:e1, $args:args, $exp:e2);|]+ ~?= [$cstm|f(1, 1, 2, 2);|]+ where+ e1 = [$cexp|1|]+ e2 = [$cexp|2|]+ args = [e1, e2]++exp_decl =+ "exp decl" ~: [$cfun|int inc(int n) {+ $decl:d1;+ $decls:decls++ return n + 1;+ }|]+ ~?= [$cfun|int inc(int n) {+ int i;+ int j;+ char c = 'c';++ return n + 1;+ }|]+ where+ d1 = [$cdecl|int i;|]+ d2 = [$cdecl|int j;|]+ d3 = [$cdecl|char c = 'c';|]+ decls = [d2, d3]++exp_sdecl =+ "exp sdecl" ~: [$cty|struct foo { $sdecl:d1 $sdecls:decls }|]+ ~?= [$cty|struct foo { int i; int j; char c; }|]+ where+ d1 = [$csdecl|int i;|]+ d2 = [$csdecl|int j;|]+ d3 = [$csdecl|char c;|]+ decls = [d2, d3]++exp_enum = "exp enum" ~: [$cty|enum foo { $enum:enum1, $enums:enums }|]+ ~?= [$cty|enum foo { A = 0, B, C = 2 }|]+ where+ enum1 = [$cenum|A = 0|]+ enum2 = [$cenum|B|]+ enum3 = [$cenum|C = 2|]+ enums = [enum2, enum3]++exp_edecl =+ "exp edecl" ~: [$cunit|$edecl:d1 $edecls:decls|]+ ~?= [$cunit|int i; int j; char c = 'c';|]+ where+ d1 = [$cedecl|int i;|]+ d2 = [$cedecl|int j;|]+ d3 = [$cedecl|char c = 'c';|]+ decls = [d2, d3]++exp_stm =+ "exp stm" ~: [$cfun|int add(int x) { $stms:stms return x + 1; }|]+ ~?= [$cfun|int add(int x) { a = 1; b = 2; return x + 1; }|]+ where+ one = 1+ stm1 = [$cstm|a = $int:one;|]+ stm2 = [$cstm|b = 2;|]+ stms = [stm1, stm2]++exp_param =+ "exp param" ~: [$cdecl|int f($param:ty1, $params:tys);|]+ ~?= [$cdecl|int f(char, int, float);|]+ where+ ty1 = [$cparam|char|]+ ty2 = [$cparam|int|]+ ty3 = [$cparam|float|]+ tys = [ty2, ty3]++exp_ty =+ "exp ty" ~: [$cdecl|$ty:ty1 f(const $ty:ty2);|]+ ~?= [$cdecl|int f(const float);|]+ where+ ty1 = [$cty|int|]+ ty2 = [$cty|float|]++pat_args =+ "pat args" ~: stms+ ~?= [[$cexp|2|], [$cexp|3|]]+ where+ stms = case [$cstm|f(1, 2, 3);|] of+ [$cstm|f(1, $args:es);|] -> es+ _ -> []