diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -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. diff --git a/Language/C.hs b/Language/C.hs new file mode 100644 --- /dev/null +++ b/Language/C.hs @@ -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 diff --git a/Language/C/Parser.hs b/Language/C/Parser.hs new file mode 100644 --- /dev/null +++ b/Language/C/Parser.hs @@ -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) diff --git a/Language/C/Parser/Lexer.x b/Language/C/Parser/Lexer.x new file mode 100644 --- /dev/null +++ b/Language/C/Parser/Lexer.x @@ -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 :- + + { + "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) +} diff --git a/Language/C/Parser/Monad.hs b/Language/C/Parser/Monad.hs new file mode 100644 --- /dev/null +++ b/Language/C/Parser/Monad.hs @@ -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 diff --git a/Language/C/Parser/Parser.y b/Language/C/Parser/Parser.y new file mode 100644 --- /dev/null +++ b/Language/C/Parser/Parser.y @@ -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) +} diff --git a/Language/C/Parser/Tokens.hs b/Language/C/Parser/Tokens.hs new file mode 100644 --- /dev/null +++ b/Language/C/Parser/Tokens.hs @@ -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) diff --git a/Language/C/Pretty.hs b/Language/C/Pretty.hs new file mode 100644 --- /dev/null +++ b/Language/C/Pretty.hs @@ -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 "!" diff --git a/Language/C/Quote/Base.hs b/Language/C/Quote/Base.hs new file mode 100644 --- /dev/null +++ b/Language/C/Quote/Base.hs @@ -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 diff --git a/Language/C/Quote/C.hs b/Language/C/Quote/C.hs new file mode 100644 --- /dev/null +++ b/Language/C/Quote/C.hs @@ -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 diff --git a/Language/C/Quote/CUDA.hs b/Language/C/Quote/CUDA.hs new file mode 100644 --- /dev/null +++ b/Language/C/Quote/CUDA.hs @@ -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 diff --git a/Language/C/Quote/GCC.hs b/Language/C/Quote/GCC.hs new file mode 100644 --- /dev/null +++ b/Language/C/Quote/GCC.hs @@ -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 diff --git a/Language/C/Smart.hs b/Language/C/Smart.hs new file mode 100644 --- /dev/null +++ b/Language/C/Smart.hs @@ -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;|] diff --git a/Language/C/Syntax.hs b/Language/C/Syntax.hs new file mode 100644 --- /dev/null +++ b/Language/C/Syntax.hs @@ -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) diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -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" diff --git a/dist/build/Language/C/Parser/Lexer.hs b/dist/build/Language/C/Parser/Lexer.hs new file mode 100644 --- /dev/null +++ b/dist/build/Language/C/Parser/Lexer.hs @@ -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 "" #-} +{-# LINE 1 "" #-} +{-# 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 diff --git a/dist/build/Language/C/Parser/Parser.hs b/dist/build/Language/C/Parser/Parser.hs new file mode 100644 --- /dev/null +++ b/dist/build/Language/C/Parser/Parser.hs @@ -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 "" #-} +{-# LINE 1 "" #-} +{-# 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. diff --git a/language-c-quote.cabal b/language-c-quote.cabal new file mode 100644 --- /dev/null +++ b/language-c-quote.cabal @@ -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 +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/ diff --git a/tests/unit/Main.hs b/tests/unit/Main.hs new file mode 100644 --- /dev/null +++ b/tests/unit/Main.hs @@ -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 + _ -> []