diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright (c) 2008 Iavor S. Diatchki, Thomas Hallgren + +All rights reserved. + +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 author nor the names of his contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS 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/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,3 @@ +import Distribution.Simple + +main = defaultMain diff --git a/graphmod.cabal b/graphmod.cabal new file mode 100644 --- /dev/null +++ b/graphmod.cabal @@ -0,0 +1,19 @@ +name: graphmod +version: 1.1 +license: BSD3 +license-file: LICENSE +author: Iavor S. Diatchki +maintainer: iavor.diatchki@gmail.com +build-type: Simple +cabal-version: >= 1.2 +synopsis: Present the module dependecies of a program as a "dot" graph. +description: This package contains a program that can compute "dot" grpahs + from the dependecies between a number of Haskell modules. +category: Development + +executable graphmod + main-is: Main.hs + other-modules: Utils, HsLayoutPre, HsLexerPass1, HsLexerPos + other-modules: HsLex, HsLexUtils, HsTokens + build-depends: base, directory, filepath, dotgen >= 0.1.1 + hs-source-dirs: src, src/lexer diff --git a/src/Main.hs b/src/Main.hs new file mode 100644 --- /dev/null +++ b/src/Main.hs @@ -0,0 +1,194 @@ +import Utils + +import Data.Dot + +import Control.Monad(when,forM_) +import Control.Monad.Fix(mfix) +import Data.List(intersperse) +import Data.Maybe(mapMaybe,isJust) +import System.Environment(getArgs) +import System.IO(hPutStrLn,stderr) +import System.FilePath +import System.Console.GetOpt +import Numeric(showHex) + +main = do xs <- getArgs + let (fs, ms, errs) = getOpt Permute options xs + case errs of + [] -> do let opts = foldr ($) default_opts fs + g <- graph (add_current opts) (map to_input ms) + putStrLn (make_dot (use_clusters opts) g) + _ -> hPutStrLn stderr $ usageInfo "mods" options + + +data Input = File FilePath | Module ModName + +-- | Guess if we have a file or a module name +to_input :: String -> Input +to_input m + | takeExtension m `elem` suffixes = File m + | otherwise = Module (splitModName m) + + + + +type Edges = [(Int,[Int])] + +graph :: Opts -> [Input] -> IO (Edges, Trie) +graph opts ms = mfix (\ ~(_,g) -> loop g empty [] 0 ms) + where + loop :: Trie -> Trie -> Edges -> Int -> [Input] -> IO (Edges, Trie) + loop _ done es _ [] = return (es,done) + loop mods done es size (Module m:ms) + | isJust (lkp done m) = loop mods done es size ms + | otherwise = + do fs <- modToFile (inc_dirs opts) m + let size1 = size + 1 + seq size1 $ case fs of + [] -> do warn opts (notFoundMsg m) + if with_missing opts + then add mods done es size m [] ms + else loop mods done es size ms + f : gs -> do when (not (null gs)) (warn opts (ambigMsg m fs)) + (x,imps) <- parseFile f + add mods done es size x imps ms + + loop mods done es size (File f:ms) = + do (m,is) <- parseFile f + case lkp done m of + Just {} -> loop mods done es size ms + Nothing -> add mods done es size m is ms + + add mods done es size m imps ms = + let deps = mapMaybe (lkp mods) imps + size1 = size + 1 + in size1 `seq` loop mods (ins (m,size) done) + ((size,deps) : es) + size1 + (map Module imps ++ ms) + + + +-- We use tries to group modules by directory. +-------------------------------------------------------------------------------- + +-- | The labels on the nodes correspond to directories, +-- the nodes on the leaves correspond to (unqualified) modules. +-- Eeach module has a unique number. +data Trie = Sub [(String, Trie)] [(String,Int)] deriving Show +empty = Sub [] [] + +lkp (Sub _ bs) ([],a) = lookup a bs +lkp (Sub as _) (k:ks,a) = (`lkp` (ks,a)) =<< lookup k as + + +ins (([],x),n) (Sub as bs) = Sub as ((x,n):bs) +ins ((a:as,x),n) (Sub ts bs) = Sub (upd ts) bs + where new = ((as,x),n) + + upd ((k,t):ts) + | k < a = (k,t) : upd ts + | k == a = (k, ins new t) : ts + upd ts = (a, ins new empty) : ts + + +-- Render edges and a trie into the dot language +-------------------------------------------------------------------------------- + +make_dot cl (es,t) = + showDot $ + do if cl then make_clustered_dot 0 t + else make_unclustered_dot 0 "" t >> return () + forM_ es $ \(x,ys) -> forM_ ys $ \y -> userNodeId x .->. userNodeId y + + +make_clustered_dot c (Sub xs ys) = + do forM_ ys $ \(xs,n) -> userNode (userNodeId n) [("label",xs)] + forM_ xs $ \(name,sub) -> + cluster $ + do attribute ("label", name) + attribute ("color" , colors !! c) + attribute ("style", "filled") + let c1 = c + 1 + c1 `seq` make_clustered_dot c1 sub + + +make_unclustered_dot c pre (Sub xs ys) = + do forM_ ys $ \(xs,n) -> userNode (userNodeId n) [ ("label", pre ++ xs) + , ("color", colors !! c) + , ("style", "filled") + ] + let c1 = if null ys then c else c + 1 + c1 `seq` loop xs c1 + where + loop ((name,sub):xs) c1 = + do let pre1 = pre ++ name ++ "." + c2 <- make_unclustered_dot c1 pre1 sub + loop xs c2 + loop [] c2 = return c2 + + + +-- XXX: generate all? +colors = map col (ys1 ++ ys2) ++ repeat "#cccccc" + where + xs1 = [ (1,0,1), (2,0,2), (3,0,3), (2,1,2), (3,1,3), (3,2,3) ] + xs2 = map rotR xs1 + xs3 = map rotR xs2 + ys1 = xs1 ++ xs2 ++ xs3 + ys2 = map compl (reverse ys1) + + col (x,y,z) = '#' : (showHex (mk x) $ showHex (mk y) $ showHex (mk z) "") + mk n = 0xFF - n * 0x33 + rotR (x,y,z) = (z,x,y) + compl (x,y,z) = (3-x,3-y,3-z) + +-- Warnings and error messages +-------------------------------------------------------------------------------- +err msg = error ("ERROR: " ++ msg) + +warn o _ | quiet o = return () +warn _ msg = hPutStrLn stderr ("WARNING: " ++ msg) + +notFoundMsg :: ModName -> String +notFoundMsg m = "Cannot find a file for module " + ++ joinModName m ++ " (ignoring)" + +ambigMsg :: ModName -> [FilePath] -> String +ambigMsg m xs = "Multiple files for module " ++ joinModName m + ++ " (picking the first):\n" + ++ concat (intersperse "," xs) + +-- Command line options +-------------------------------------------------------------------------------- +data Opts = Opts + { inc_dirs :: [FilePath] + , quiet :: Bool + , with_missing :: Bool + , use_clusters :: Bool + } + +default_opts = Opts + { inc_dirs = [] + , quiet = False + , with_missing = False + , use_clusters = True + } + +add_current o = case inc_dirs o of + [] -> o { inc_dirs = ["."] } + _ -> o +options = + [ Option ['q'] ["quiet"] (NoArg set_quiet) "Do not show warnings" + , Option ['i'] [] (ReqArg add_inc "DIR") "Add a search directory" + , Option ['a'] ["all"] (NoArg set_all) "Add nodes for missing modules" + , Option [] ["no-cluster"] (NoArg set_no_cluster) + "Do not cluster directories" + ] + +set_quiet o = o { quiet = True } +set_all o = o { with_missing = True } +add_inc d o = o { inc_dirs = d : inc_dirs o } +set_no_cluster o = o { use_clusters = False } + + diff --git a/src/Utils.hs b/src/Utils.hs new file mode 100644 --- /dev/null +++ b/src/Utils.hs @@ -0,0 +1,93 @@ +module Utils + ( parseFile + , parseString + , ModName + , splitModName + , joinModName + , relPaths + , modToFile + , suffixes + ) where + +import HsLexerPass1(lexerPass1) +import HsTokens + +import Data.Maybe(catMaybes) +import Data.List(intersperse,isPrefixOf) +import System.Directory(doesFileExist) +import System.FilePath + +import Debug.Trace + +-- | Get the imports of a file. +parseFile :: FilePath -> IO (ModName,[ModName]) +parseFile f = (parseString . get_text) `fmap` readFile f + where get_text txt = if takeExtension f == ".lhs" then delit txt else txt + +-- | Get the imports from a string that represents a program. +parseString :: String -> (ModName,[ModName]) +parseString = parse . lexerPass1 + + +isImp (_ : (Conid, (_,x)) : xs) = Just (x,xs) +isImp (_ : (Qconid, (_,x)) : xs) = Just (x,xs) +isImp (_ : (Specialid,_) : (Conid, (_,x)) : xs) = Just (x,xs) +isImp (_ : (Specialid,_) : (Qconid, (_,x)) : xs) = Just (x,xs) +isImp _ = Nothing + +-- parse xs | trace (show (take 10 xs)) False = undefined +parse (_ : (Reservedid,(_,"module")) : (_,(_,m)) : is) = + (splitModName m,imports is) +parse is = {-trace ("Defaulting to Main: " ++ show (take 10 is))-} + (([],"Main"),imports is) + +imports xs = case isImp $ snd $ break (("import" ==) . snd . snd) xs of + Just (x,xs) -> splitModName x : imports xs + _ -> [] + +-- | A hirarchical module name. +type ModName = ([String],String) + +-- | Convert a string name into a hirarchical name. +splitModName :: String -> ModName +splitModName xs = case break ('.'==) xs of + (xs,_:ys) -> let (as,bs) = splitModName ys + in (xs:as,bs) + _ -> ([],xs) + +joinModName :: ModName -> String +joinModName (xs,y) = concat $ intersperse "." (xs ++ [y]) + +-- | The files in which a module moght reside. +relPaths :: ModName -> [FilePath] +relPaths (xs,y) = [ prefix ++ suffix | suffix <- suffixes ] + where prefix = foldr () y xs + +suffixes = [".hs",".lhs"] + +-- | The files in which a module might reside. +-- We report only files that exist. +modToFile :: [FilePath] -> ModName -> IO [FilePath] +modToFile dirs m = catMaybes `fmap` mapM check paths + where + paths = [ d r | d <- dirs, r <- relPaths m ] + check p = do x <- doesFileExist p + return (if x then Just p else Nothing) + + +delit :: String -> String +delit txt = unlines $ bird $ lines txt + where + bird (('>' : cs) : ls) = (' ' : cs) : bird ls + bird (l : ls) + | "\\begin{code}" `isPrefixOf` l = in_code ls + | otherwise = bird ls + bird [] = [] + + in_code (l : ls) + | "\\end{code}" `isPrefixOf` l = bird ls + | otherwise = l : in_code ls + in_code [] = [] -- unterminated code... + + + diff --git a/src/lexer/HsLayoutPre.hs b/src/lexer/HsLayoutPre.hs new file mode 100644 --- /dev/null +++ b/src/lexer/HsLayoutPre.hs @@ -0,0 +1,61 @@ +module HsLayoutPre(layoutPre,PosToken) where +import HsTokens +import HsLexerPos + +{-+ +This is +an implementation of Haskell layout, as specified in section 9.3 of the +revised Haskell 98 report. + +This module contains the layout preprocessor that inserts the extra +<n> and {n} tokens. +-} + +type PosToken = (Token,(Pos,String)) + +layoutPre :: [PosToken] -> [PosToken] +layoutPre = indent . open + +open = open1 + +{-+ +If the first lexeme of a module is not { or module, then it is preceded +by {n} where n is the indentation of the lexeme. +-} +open1 (t1@(Reservedid,(_,"module")):ts) = t1:open2 ts +open1 (t1@(Special,(_,"{")):ts) = t1:open2 ts +open1 ts@((t,(p,s)):_) = (Open (column p),(p,"")):open2 ts +open1 [] = [] + +{-+ +If a let, where, do, or of keyword is not followed by the lexeme {, +the token {n} is inserted after the keyword, where n is the indentation of +the next lexeme if there is one, or 0 if the end of file has been reached. +-} +open2 (t1:ts1) | isLtoken t1 = + case ts1 of + t2@(_,(p,_)):ts2 -> + if notLBrace t2 + then t1:(Open (column p),(p,"")):open2 ts1 + else t1:t2:open2 ts2 + [] -> t1:(Open 0,(fst (snd t1),"")):[] + where + isLtoken (Reservedid,(_,s)) = s `elem` ["let","where","do","of"] + isLtoken _ = False + + notLBrace (Special,(_,"{")) = False + notLBrace _ = True +open2 (t:ts) = t:open2 ts +open2 [] = [] + +{-+ +(This is from the original Haskell 98 report.) +The first token on each line (not including tokens already annotated) is +preceeded by <n>, where n is the indentation of the token. +-} +indent (t1@(Open _,(p,_)):ts) = t1:indent2 (line p) ts +indent (t1@(t,(p,s)):ts) = (Indent (column p),(p,"")):t1:indent2 (line p) ts +indent [] = [] + +indent2 r (t1@(_,(p,_)):ts) | line p==r = t1:indent2 r ts +indent2 r ts = indent ts diff --git a/src/lexer/HsLex.hs b/src/lexer/HsLex.hs new file mode 100644 --- /dev/null +++ b/src/lexer/HsLex.hs @@ -0,0 +1,5366 @@ + +-- Automatically generated code for a DFA follows: +--Equal states: [[[2,3],[8,9],[5,31],[10,11],[36,37],[39,40]]] +module HsLex (haskellLex) where +import Data.Char +import HsLexUtils + +type Output = [(Token,String)] +type Input = String +type Acc = Input -- reversed +type Lexer = Input -> Output +type LexerState = (Acc->Lexer) -> Acc -> Lexer + +haskellLex :: Lexer +haskellLex is = start1 is + +cclass :: Char -> Int +cclass c = + case c of + '\t' -> 1 + '\n' -> 2 + '\v' -> 3 + '\f' -> 4 + '\r' -> 5 + ' ' -> 6 + '\160' -> 6 + '!' -> 7 + '#' -> 7 + '$' -> 7 + '%' -> 7 + '*' -> 7 + '/' -> 7 + '?' -> 7 + '\161' -> 7 + '\162' -> 7 + '\163' -> 7 + '\164' -> 7 + '\165' -> 7 + '\166' -> 7 + '\167' -> 7 + '\168' -> 7 + '\169' -> 7 + '\172' -> 7 + '\173' -> 7 + '\174' -> 7 + '\175' -> 7 + '\176' -> 7 + '\177' -> 7 + '\180' -> 7 + '\182' -> 7 + '\183' -> 7 + '\184' -> 7 + '\191' -> 7 + '\215' -> 7 + '\247' -> 7 + '"' -> 8 + '&' -> 9 + '\'' -> 10 + '(' -> 11 + ')' -> 11 + ',' -> 11 + ';' -> 11 + '`' -> 11 + '}' -> 11 + '+' -> 12 + '-' -> 13 + '.' -> 14 + '0' -> 15 + '1' -> 16 + '2' -> 16 + '3' -> 16 + '4' -> 16 + '5' -> 17 + '6' -> 17 + '7' -> 17 + '8' -> 18 + '9' -> 18 + ':' -> 19 + '<' -> 20 + '=' -> 21 + '>' -> 22 + '@' -> 23 + 'A' -> 24 + 'B' -> 25 + 'C' -> 26 + 'D' -> 27 + 'E' -> 28 + 'F' -> 29 + 'G' -> 30 + 'H' -> 31 + 'I' -> 32 + 'P' -> 32 + 'J' -> 33 + 'W' -> 33 + 'Z' -> 33 + 'K' -> 34 + 'L' -> 35 + 'M' -> 36 + 'N' -> 37 + 'O' -> 38 + 'Q' -> 39 + 'R' -> 40 + 'S' -> 41 + 'T' -> 42 + 'U' -> 43 + 'V' -> 44 + 'X' -> 45 + 'Y' -> 46 + '[' -> 47 + ']' -> 47 + '\\' -> 48 + '^' -> 49 + '_' -> 50 + 'a' -> 51 + 'b' -> 52 + 'c' -> 53 + 'd' -> 54 + 'e' -> 55 + 'f' -> 56 + 'g' -> 57 + 'h' -> 58 + 'i' -> 59 + 'j' -> 60 + 'k' -> 60 + 'q' -> 60 + 'z' -> 60 + '\223' -> 60 + '\224' -> 60 + '\225' -> 60 + '\226' -> 60 + '\227' -> 60 + '\228' -> 60 + '\229' -> 60 + '\230' -> 60 + '\231' -> 60 + '\232' -> 60 + '\233' -> 60 + '\234' -> 60 + '\235' -> 60 + '\236' -> 60 + '\237' -> 60 + '\238' -> 60 + '\239' -> 60 + '\240' -> 60 + '\241' -> 60 + '\242' -> 60 + '\243' -> 60 + '\244' -> 60 + '\245' -> 60 + '\246' -> 60 + '\248' -> 60 + '\249' -> 60 + '\250' -> 60 + '\251' -> 60 + '\252' -> 60 + '\253' -> 60 + '\254' -> 60 + '\255' -> 60 + 'l' -> 61 + 'm' -> 62 + 'n' -> 63 + 'o' -> 64 + 'p' -> 65 + 'r' -> 66 + 's' -> 67 + 't' -> 68 + 'u' -> 69 + 'v' -> 70 + 'w' -> 71 + 'x' -> 72 + 'y' -> 73 + '{' -> 74 + '|' -> 75 + '~' -> 75 + '\170' -> 76 + '\171' -> 76 + '\178' -> 76 + '\179' -> 76 + '\181' -> 76 + '\185' -> 76 + '\186' -> 76 + '\187' -> 76 + '\188' -> 76 + '\189' -> 76 + '\190' -> 76 + '\192' -> 77 + '\193' -> 77 + '\194' -> 77 + '\195' -> 77 + '\196' -> 77 + '\197' -> 77 + '\198' -> 77 + '\199' -> 77 + '\200' -> 77 + '\201' -> 77 + '\202' -> 77 + '\203' -> 77 + '\204' -> 77 + '\205' -> 77 + '\206' -> 77 + '\207' -> 77 + '\208' -> 77 + '\209' -> 77 + '\210' -> 77 + '\211' -> 77 + '\212' -> 77 + '\213' -> 77 + '\214' -> 77 + '\216' -> 77 + '\217' -> 77 + '\218' -> 77 + '\219' -> 77 + '\220' -> 77 + '\221' -> 77 + '\222' -> 77 + c | isAscii c -> 0 + | isSpace c -> 3 + | isSymbol c -> 7 + | isDigit c -> 18 + | isLower c -> 60 + | isUpper c -> 77 + | otherwise -> 0 + +start1 :: Lexer +start1 is = state1 (\ as is -> gotError as is) "" is +state1 :: LexerState +state1 err as [] = gotEOF as +state1 err as iis@(i:is) = + case cclass i of + 51 -> state162 err (i:as) is + 52 -> state162 err (i:as) is + 56 -> state162 err (i:as) is + 57 -> state162 err (i:as) is + 58 -> state162 err (i:as) is + 60 -> state162 err (i:as) is + 65 -> state162 err (i:as) is + 66 -> state162 err (i:as) is + 67 -> state162 err (i:as) is + 69 -> state162 err (i:as) is + 70 -> state162 err (i:as) is + 72 -> state162 err (i:as) is + 73 -> state162 err (i:as) is + 1 -> state2 err (i:as) is + 2 -> state2 err (i:as) is + 3 -> state2 err (i:as) is + 4 -> state2 err (i:as) is + 5 -> state2 err (i:as) is + 6 -> state2 err (i:as) is + 7 -> state4 err (i:as) is + 9 -> state4 err (i:as) is + 12 -> state4 err (i:as) is + 22 -> state4 err (i:as) is + 49 -> state4 err (i:as) is + 23 -> state79 err (i:as) is + 48 -> state79 err (i:as) is + 75 -> state79 err (i:as) is + 16 -> state87 err (i:as) is + 17 -> state87 err (i:as) is + 18 -> state87 err (i:as) is + 0 -> err as iis + 76 -> err as iis + 11 -> state73 err (i:as) is + 47 -> state73 err (i:as) is + 8 -> state5 err (i:as) is + 10 -> state41 err (i:as) is + 13 -> state74 err (i:as) is + 14 -> state80 err (i:as) is + 15 -> state81 err (i:as) is + 19 -> state92 err (i:as) is + 20 -> state95 err (i:as) is + 21 -> state96 err (i:as) is + 50 -> state161 err (i:as) is + 53 -> state163 err (i:as) is + 54 -> state169 err (i:as) is + 55 -> state182 err (i:as) is + 59 -> state183 err (i:as) is + 61 -> state195 err (i:as) is + 62 -> state196 err (i:as) is + 63 -> state200 err (i:as) is + 64 -> state205 err (i:as) is + 68 -> state206 err (i:as) is + 71 -> state209 err (i:as) is + 74 -> state212 err (i:as) is + _ -> state97 err (i:as) is + +state2 :: LexerState +state2 err as [] = err as [] + where err _ _ = output Whitespace as (start1 []) +state2 err as iis@(i:is) = + case cclass i of + 1 -> state2 err (i:as) is + 2 -> state2 err (i:as) is + 3 -> state2 err (i:as) is + 4 -> state2 err (i:as) is + 5 -> state2 err (i:as) is + 6 -> state2 err (i:as) is + _ -> err as iis + where err _ _ = output Whitespace as (start1 iis) + +state4 :: LexerState +state4 err as [] = err as [] + where err _ _ = output Varsym as (start1 []) +state4 err as iis@(i:is) = + case cclass i of + 7 -> state4 err (i:as) is + 9 -> state4 err (i:as) is + 12 -> state4 err (i:as) is + 13 -> state4 err (i:as) is + 14 -> state4 err (i:as) is + 19 -> state4 err (i:as) is + 20 -> state4 err (i:as) is + 21 -> state4 err (i:as) is + 22 -> state4 err (i:as) is + 23 -> state4 err (i:as) is + 48 -> state4 err (i:as) is + 49 -> state4 err (i:as) is + 75 -> state4 err (i:as) is + _ -> err as iis + where err _ _ = output Varsym as (start1 iis) + +start5 :: Lexer +start5 is = state5 (\ as is -> gotError as is) "" is +state5 :: LexerState +state5 err as [] = err as [] +state5 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 8 -> state6 err (i:as) is + 48 -> state7 err (i:as) is + _ -> state5 err (i:as) is + +state6 :: LexerState +state6 err as is = output StringLit as (start1 is) + +start7 :: Lexer +start7 is = state7 (\ as is -> gotError as is) "" is +state7 :: LexerState +state7 err as [] = err as [] +state7 err as iis@(i:is) = + case cclass i of + 8 -> state5 err (i:as) is + 9 -> state5 err (i:as) is + 10 -> state5 err (i:as) is + 48 -> state5 err (i:as) is + 51 -> state5 err (i:as) is + 52 -> state5 err (i:as) is + 56 -> state5 err (i:as) is + 63 -> state5 err (i:as) is + 66 -> state5 err (i:as) is + 68 -> state5 err (i:as) is + 70 -> state5 err (i:as) is + 1 -> state8 err (i:as) is + 2 -> state8 err (i:as) is + 3 -> state8 err (i:as) is + 4 -> state8 err (i:as) is + 5 -> state8 err (i:as) is + 6 -> state8 err (i:as) is + 15 -> state10 err (i:as) is + 16 -> state10 err (i:as) is + 17 -> state10 err (i:as) is + 18 -> state10 err (i:as) is + 30 -> state27 err (i:as) is + 40 -> state27 err (i:as) is + 43 -> state27 err (i:as) is + 31 -> state23 err (i:as) is + 44 -> state23 err (i:as) is + 24 -> state12 err (i:as) is + 25 -> state14 err (i:as) is + 26 -> state16 err (i:as) is + 27 -> state18 err (i:as) is + 28 -> state21 err (i:as) is + 29 -> state26 err (i:as) is + 35 -> state28 err (i:as) is + 37 -> state29 err (i:as) is + 41 -> state30 err (i:as) is + 49 -> state34 err (i:as) is + 64 -> state35 err (i:as) is + 72 -> state38 err (i:as) is + _ -> err as iis + +start8 :: Lexer +start8 is = state8 (\ as is -> gotError as is) "" is +state8 :: LexerState +state8 err as [] = err as [] +state8 err as iis@(i:is) = + case cclass i of + 1 -> state8 err (i:as) is + 2 -> state8 err (i:as) is + 3 -> state8 err (i:as) is + 4 -> state8 err (i:as) is + 5 -> state8 err (i:as) is + 6 -> state8 err (i:as) is + 48 -> state5 err (i:as) is + _ -> err as iis + +start10 :: Lexer +start10 is = state10 (\ as is -> gotError as is) "" is +state10 :: LexerState +state10 err as [] = err as [] +state10 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 15 -> state10 err (i:as) is + 16 -> state10 err (i:as) is + 17 -> state10 err (i:as) is + 18 -> state10 err (i:as) is + 8 -> state6 err (i:as) is + 48 -> state7 err (i:as) is + _ -> state5 err (i:as) is + +start12 :: Lexer +start12 is = state12 (\ as is -> gotError as is) "" is +state12 :: LexerState +state12 err as [] = err as [] +state12 err as iis@(i:is) = + case cclass i of + 26 -> state13 err (i:as) is + _ -> err as iis + +start13 :: Lexer +start13 is = state13 (\ as is -> gotError as is) "" is +state13 :: LexerState +state13 err as [] = err as [] +state13 err as iis@(i:is) = + case cclass i of + 34 -> state5 err (i:as) is + _ -> err as iis + +start14 :: Lexer +start14 is = state14 (\ as is -> gotError as is) "" is +state14 :: LexerState +state14 err as [] = err as [] +state14 err as iis@(i:is) = + case cclass i of + 41 -> state5 err (i:as) is + 28 -> state15 err (i:as) is + _ -> err as iis + +start15 :: Lexer +start15 is = state15 (\ as is -> gotError as is) "" is +state15 :: LexerState +state15 err as [] = err as [] +state15 err as iis@(i:is) = + case cclass i of + 35 -> state5 err (i:as) is + _ -> err as iis + +start16 :: Lexer +start16 is = state16 (\ as is -> gotError as is) "" is +state16 :: LexerState +state16 err as [] = err as [] +state16 err as iis@(i:is) = + case cclass i of + 40 -> state5 err (i:as) is + 24 -> state17 err (i:as) is + _ -> err as iis + +start17 :: Lexer +start17 is = state17 (\ as is -> gotError as is) "" is +state17 :: LexerState +state17 err as [] = err as [] +state17 err as iis@(i:is) = + case cclass i of + 37 -> state5 err (i:as) is + _ -> err as iis + +start18 :: Lexer +start18 is = state18 (\ as is -> gotError as is) "" is +state18 :: LexerState +state18 err as [] = err as [] +state18 err as iis@(i:is) = + case cclass i of + 28 -> state15 err (i:as) is + 26 -> state19 err (i:as) is + 35 -> state20 err (i:as) is + _ -> err as iis + +start19 :: Lexer +start19 is = state19 (\ as is -> gotError as is) "" is +state19 :: LexerState +state19 err as [] = err as [] +state19 err as iis@(i:is) = + case cclass i of + 16 -> state5 err (i:as) is + _ -> err as iis + +start20 :: Lexer +start20 is = state20 (\ as is -> gotError as is) "" is +state20 :: LexerState +state20 err as [] = err as [] +state20 err as iis@(i:is) = + case cclass i of + 28 -> state5 err (i:as) is + _ -> err as iis + +start21 :: Lexer +start21 is = state21 (\ as is -> gotError as is) "" is +state21 :: LexerState +state21 err as [] = err as [] +state21 err as iis@(i:is) = + case cclass i of + 36 -> state5 err (i:as) is + 37 -> state22 err (i:as) is + 38 -> state23 err (i:as) is + 41 -> state24 err (i:as) is + 42 -> state25 err (i:as) is + _ -> err as iis + +start22 :: Lexer +start22 is = state22 (\ as is -> gotError as is) "" is +state22 :: LexerState +state22 err as [] = err as [] +state22 err as iis@(i:is) = + case cclass i of + 39 -> state5 err (i:as) is + _ -> err as iis + +start23 :: Lexer +start23 is = state23 (\ as is -> gotError as is) "" is +state23 :: LexerState +state23 err as [] = err as [] +state23 err as iis@(i:is) = + case cclass i of + 42 -> state5 err (i:as) is + _ -> err as iis + +start24 :: Lexer +start24 is = state24 (\ as is -> gotError as is) "" is +state24 :: LexerState +state24 err as [] = err as [] +state24 err as iis@(i:is) = + case cclass i of + 26 -> state5 err (i:as) is + _ -> err as iis + +start25 :: Lexer +start25 is = state25 (\ as is -> gotError as is) "" is +state25 :: LexerState +state25 err as [] = err as [] +state25 err as iis@(i:is) = + case cclass i of + 25 -> state5 err (i:as) is + 45 -> state5 err (i:as) is + _ -> err as iis + +start26 :: Lexer +start26 is = state26 (\ as is -> gotError as is) "" is +state26 :: LexerState +state26 err as [] = err as [] +state26 err as iis@(i:is) = + case cclass i of + 29 -> state5 err (i:as) is + 41 -> state5 err (i:as) is + _ -> err as iis + +start27 :: Lexer +start27 is = state27 (\ as is -> gotError as is) "" is +state27 :: LexerState +state27 err as [] = err as [] +state27 err as iis@(i:is) = + case cclass i of + 41 -> state5 err (i:as) is + _ -> err as iis + +start28 :: Lexer +start28 is = state28 (\ as is -> gotError as is) "" is +state28 :: LexerState +state28 err as [] = err as [] +state28 err as iis@(i:is) = + case cclass i of + 29 -> state5 err (i:as) is + _ -> err as iis + +start29 :: Lexer +start29 is = state29 (\ as is -> gotError as is) "" is +state29 :: LexerState +state29 err as [] = err as [] +state29 err as iis@(i:is) = + case cclass i of + 24 -> state13 err (i:as) is + 43 -> state15 err (i:as) is + _ -> err as iis + +start30 :: Lexer +start30 is = state30 (\ as is -> gotError as is) "" is +state30 :: LexerState +state30 err as [] = err as [] +state30 err as iis@(i:is) = + case cclass i of + 32 -> state5 err (i:as) is + 38 -> state5 err (i:as) is + 46 -> state17 err (i:as) is + 42 -> state32 err (i:as) is + 43 -> state33 err (i:as) is + _ -> err as iis + +start32 :: Lexer +start32 is = state32 (\ as is -> gotError as is) "" is +state32 :: LexerState +state32 err as [] = err as [] +state32 err as iis@(i:is) = + case cclass i of + 45 -> state5 err (i:as) is + _ -> err as iis + +start33 :: Lexer +start33 is = state33 (\ as is -> gotError as is) "" is +state33 :: LexerState +state33 err as [] = err as [] +state33 err as iis@(i:is) = + case cclass i of + 25 -> state5 err (i:as) is + _ -> err as iis + +start34 :: Lexer +start34 is = state34 (\ as is -> gotError as is) "" is +state34 :: LexerState +state34 err as [] = err as [] +state34 err as iis@(i:is) = + case cclass i of + 23 -> state5 err (i:as) is + 24 -> state5 err (i:as) is + 25 -> state5 err (i:as) is + 26 -> state5 err (i:as) is + 27 -> state5 err (i:as) is + 28 -> state5 err (i:as) is + 29 -> state5 err (i:as) is + 30 -> state5 err (i:as) is + 31 -> state5 err (i:as) is + 32 -> state5 err (i:as) is + 33 -> state5 err (i:as) is + 34 -> state5 err (i:as) is + 35 -> state5 err (i:as) is + 36 -> state5 err (i:as) is + 37 -> state5 err (i:as) is + 38 -> state5 err (i:as) is + 39 -> state5 err (i:as) is + 40 -> state5 err (i:as) is + 41 -> state5 err (i:as) is + 42 -> state5 err (i:as) is + 43 -> state5 err (i:as) is + 44 -> state5 err (i:as) is + 45 -> state5 err (i:as) is + 46 -> state5 err (i:as) is + 47 -> state5 err (i:as) is + 48 -> state5 err (i:as) is + 49 -> state5 err (i:as) is + 50 -> state5 err (i:as) is + _ -> err as iis + +start35 :: Lexer +start35 is = state35 (\ as is -> gotError as is) "" is +state35 :: LexerState +state35 err as [] = err as [] +state35 err as iis@(i:is) = + case cclass i of + 15 -> state36 err (i:as) is + 16 -> state36 err (i:as) is + 17 -> state36 err (i:as) is + _ -> err as iis + +start36 :: Lexer +start36 is = state36 (\ as is -> gotError as is) "" is +state36 :: LexerState +state36 err as [] = err as [] +state36 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 15 -> state36 err (i:as) is + 16 -> state36 err (i:as) is + 17 -> state36 err (i:as) is + 8 -> state6 err (i:as) is + 48 -> state7 err (i:as) is + _ -> state5 err (i:as) is + +start38 :: Lexer +start38 is = state38 (\ as is -> gotError as is) "" is +state38 :: LexerState +state38 err as [] = err as [] +state38 err as iis@(i:is) = + case cclass i of + 15 -> state39 err (i:as) is + 16 -> state39 err (i:as) is + 17 -> state39 err (i:as) is + 18 -> state39 err (i:as) is + 24 -> state39 err (i:as) is + 25 -> state39 err (i:as) is + 26 -> state39 err (i:as) is + 27 -> state39 err (i:as) is + 28 -> state39 err (i:as) is + 29 -> state39 err (i:as) is + 51 -> state39 err (i:as) is + 52 -> state39 err (i:as) is + 53 -> state39 err (i:as) is + 54 -> state39 err (i:as) is + 55 -> state39 err (i:as) is + 56 -> state39 err (i:as) is + _ -> err as iis + +start39 :: Lexer +start39 is = state39 (\ as is -> gotError as is) "" is +state39 :: LexerState +state39 err as [] = err as [] +state39 err as iis@(i:is) = + case cclass i of + 15 -> state39 err (i:as) is + 16 -> state39 err (i:as) is + 17 -> state39 err (i:as) is + 18 -> state39 err (i:as) is + 24 -> state39 err (i:as) is + 25 -> state39 err (i:as) is + 26 -> state39 err (i:as) is + 27 -> state39 err (i:as) is + 28 -> state39 err (i:as) is + 29 -> state39 err (i:as) is + 51 -> state39 err (i:as) is + 52 -> state39 err (i:as) is + 53 -> state39 err (i:as) is + 54 -> state39 err (i:as) is + 55 -> state39 err (i:as) is + 56 -> state39 err (i:as) is + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 8 -> state6 err (i:as) is + 48 -> state7 err (i:as) is + _ -> state5 err (i:as) is + +start41 :: Lexer +start41 is = state41 (\ as is -> gotError as is) "" is +state41 :: LexerState +state41 err as [] = err as [] +state41 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 10 -> err as iis + 48 -> state44 err (i:as) is + _ -> state42 err (i:as) is + +start42 :: Lexer +start42 is = state42 (\ as is -> gotError as is) "" is +state42 :: LexerState +state42 err as [] = err as [] +state42 err as iis@(i:is) = + case cclass i of + 10 -> state43 err (i:as) is + _ -> err as iis + +state43 :: LexerState +state43 err as is = output CharLit as (start1 is) + +start44 :: Lexer +start44 is = state44 (\ as is -> gotError as is) "" is +state44 :: LexerState +state44 err as [] = err as [] +state44 err as iis@(i:is) = + case cclass i of + 8 -> state42 err (i:as) is + 9 -> state42 err (i:as) is + 10 -> state42 err (i:as) is + 48 -> state42 err (i:as) is + 51 -> state42 err (i:as) is + 52 -> state42 err (i:as) is + 56 -> state42 err (i:as) is + 63 -> state42 err (i:as) is + 66 -> state42 err (i:as) is + 68 -> state42 err (i:as) is + 70 -> state42 err (i:as) is + 15 -> state45 err (i:as) is + 16 -> state45 err (i:as) is + 17 -> state45 err (i:as) is + 18 -> state45 err (i:as) is + 30 -> state61 err (i:as) is + 40 -> state61 err (i:as) is + 43 -> state61 err (i:as) is + 31 -> state57 err (i:as) is + 44 -> state57 err (i:as) is + 24 -> state46 err (i:as) is + 25 -> state48 err (i:as) is + 26 -> state50 err (i:as) is + 27 -> state52 err (i:as) is + 28 -> state55 err (i:as) is + 29 -> state60 err (i:as) is + 35 -> state62 err (i:as) is + 37 -> state63 err (i:as) is + 41 -> state64 err (i:as) is + 49 -> state68 err (i:as) is + 64 -> state69 err (i:as) is + 72 -> state71 err (i:as) is + _ -> err as iis + +start45 :: Lexer +start45 is = state45 (\ as is -> gotError as is) "" is +state45 :: LexerState +state45 err as [] = err as [] +state45 err as iis@(i:is) = + case cclass i of + 15 -> state45 err (i:as) is + 16 -> state45 err (i:as) is + 17 -> state45 err (i:as) is + 18 -> state45 err (i:as) is + 10 -> state43 err (i:as) is + _ -> err as iis + +start46 :: Lexer +start46 is = state46 (\ as is -> gotError as is) "" is +state46 :: LexerState +state46 err as [] = err as [] +state46 err as iis@(i:is) = + case cclass i of + 26 -> state47 err (i:as) is + _ -> err as iis + +start47 :: Lexer +start47 is = state47 (\ as is -> gotError as is) "" is +state47 :: LexerState +state47 err as [] = err as [] +state47 err as iis@(i:is) = + case cclass i of + 34 -> state42 err (i:as) is + _ -> err as iis + +start48 :: Lexer +start48 is = state48 (\ as is -> gotError as is) "" is +state48 :: LexerState +state48 err as [] = err as [] +state48 err as iis@(i:is) = + case cclass i of + 41 -> state42 err (i:as) is + 28 -> state49 err (i:as) is + _ -> err as iis + +start49 :: Lexer +start49 is = state49 (\ as is -> gotError as is) "" is +state49 :: LexerState +state49 err as [] = err as [] +state49 err as iis@(i:is) = + case cclass i of + 35 -> state42 err (i:as) is + _ -> err as iis + +start50 :: Lexer +start50 is = state50 (\ as is -> gotError as is) "" is +state50 :: LexerState +state50 err as [] = err as [] +state50 err as iis@(i:is) = + case cclass i of + 40 -> state42 err (i:as) is + 24 -> state51 err (i:as) is + _ -> err as iis + +start51 :: Lexer +start51 is = state51 (\ as is -> gotError as is) "" is +state51 :: LexerState +state51 err as [] = err as [] +state51 err as iis@(i:is) = + case cclass i of + 37 -> state42 err (i:as) is + _ -> err as iis + +start52 :: Lexer +start52 is = state52 (\ as is -> gotError as is) "" is +state52 :: LexerState +state52 err as [] = err as [] +state52 err as iis@(i:is) = + case cclass i of + 28 -> state49 err (i:as) is + 26 -> state53 err (i:as) is + 35 -> state54 err (i:as) is + _ -> err as iis + +start53 :: Lexer +start53 is = state53 (\ as is -> gotError as is) "" is +state53 :: LexerState +state53 err as [] = err as [] +state53 err as iis@(i:is) = + case cclass i of + 16 -> state42 err (i:as) is + _ -> err as iis + +start54 :: Lexer +start54 is = state54 (\ as is -> gotError as is) "" is +state54 :: LexerState +state54 err as [] = err as [] +state54 err as iis@(i:is) = + case cclass i of + 28 -> state42 err (i:as) is + _ -> err as iis + +start55 :: Lexer +start55 is = state55 (\ as is -> gotError as is) "" is +state55 :: LexerState +state55 err as [] = err as [] +state55 err as iis@(i:is) = + case cclass i of + 36 -> state42 err (i:as) is + 37 -> state56 err (i:as) is + 38 -> state57 err (i:as) is + 41 -> state58 err (i:as) is + 42 -> state59 err (i:as) is + _ -> err as iis + +start56 :: Lexer +start56 is = state56 (\ as is -> gotError as is) "" is +state56 :: LexerState +state56 err as [] = err as [] +state56 err as iis@(i:is) = + case cclass i of + 39 -> state42 err (i:as) is + _ -> err as iis + +start57 :: Lexer +start57 is = state57 (\ as is -> gotError as is) "" is +state57 :: LexerState +state57 err as [] = err as [] +state57 err as iis@(i:is) = + case cclass i of + 42 -> state42 err (i:as) is + _ -> err as iis + +start58 :: Lexer +start58 is = state58 (\ as is -> gotError as is) "" is +state58 :: LexerState +state58 err as [] = err as [] +state58 err as iis@(i:is) = + case cclass i of + 26 -> state42 err (i:as) is + _ -> err as iis + +start59 :: Lexer +start59 is = state59 (\ as is -> gotError as is) "" is +state59 :: LexerState +state59 err as [] = err as [] +state59 err as iis@(i:is) = + case cclass i of + 25 -> state42 err (i:as) is + 45 -> state42 err (i:as) is + _ -> err as iis + +start60 :: Lexer +start60 is = state60 (\ as is -> gotError as is) "" is +state60 :: LexerState +state60 err as [] = err as [] +state60 err as iis@(i:is) = + case cclass i of + 29 -> state42 err (i:as) is + 41 -> state42 err (i:as) is + _ -> err as iis + +start61 :: Lexer +start61 is = state61 (\ as is -> gotError as is) "" is +state61 :: LexerState +state61 err as [] = err as [] +state61 err as iis@(i:is) = + case cclass i of + 41 -> state42 err (i:as) is + _ -> err as iis + +start62 :: Lexer +start62 is = state62 (\ as is -> gotError as is) "" is +state62 :: LexerState +state62 err as [] = err as [] +state62 err as iis@(i:is) = + case cclass i of + 29 -> state42 err (i:as) is + _ -> err as iis + +start63 :: Lexer +start63 is = state63 (\ as is -> gotError as is) "" is +state63 :: LexerState +state63 err as [] = err as [] +state63 err as iis@(i:is) = + case cclass i of + 24 -> state47 err (i:as) is + 43 -> state49 err (i:as) is + _ -> err as iis + +start64 :: Lexer +start64 is = state64 (\ as is -> gotError as is) "" is +state64 :: LexerState +state64 err as [] = err as [] +state64 err as iis@(i:is) = + case cclass i of + 32 -> state42 err (i:as) is + 46 -> state51 err (i:as) is + 38 -> state65 err (i:as) is + 42 -> state66 err (i:as) is + 43 -> state67 err (i:as) is + _ -> err as iis + +start65 :: Lexer +start65 is = state65 (\ as is -> gotError as is) "" is +state65 :: LexerState +state65 err as [] = err as [] +state65 err as iis@(i:is) = + case cclass i of + 31 -> state42 err (i:as) is + 10 -> state43 err (i:as) is + _ -> err as iis + +start66 :: Lexer +start66 is = state66 (\ as is -> gotError as is) "" is +state66 :: LexerState +state66 err as [] = err as [] +state66 err as iis@(i:is) = + case cclass i of + 45 -> state42 err (i:as) is + _ -> err as iis + +start67 :: Lexer +start67 is = state67 (\ as is -> gotError as is) "" is +state67 :: LexerState +state67 err as [] = err as [] +state67 err as iis@(i:is) = + case cclass i of + 25 -> state42 err (i:as) is + _ -> err as iis + +start68 :: Lexer +start68 is = state68 (\ as is -> gotError as is) "" is +state68 :: LexerState +state68 err as [] = err as [] +state68 err as iis@(i:is) = + case cclass i of + 23 -> state42 err (i:as) is + 24 -> state42 err (i:as) is + 25 -> state42 err (i:as) is + 26 -> state42 err (i:as) is + 27 -> state42 err (i:as) is + 28 -> state42 err (i:as) is + 29 -> state42 err (i:as) is + 30 -> state42 err (i:as) is + 31 -> state42 err (i:as) is + 32 -> state42 err (i:as) is + 33 -> state42 err (i:as) is + 34 -> state42 err (i:as) is + 35 -> state42 err (i:as) is + 36 -> state42 err (i:as) is + 37 -> state42 err (i:as) is + 38 -> state42 err (i:as) is + 39 -> state42 err (i:as) is + 40 -> state42 err (i:as) is + 41 -> state42 err (i:as) is + 42 -> state42 err (i:as) is + 43 -> state42 err (i:as) is + 44 -> state42 err (i:as) is + 45 -> state42 err (i:as) is + 46 -> state42 err (i:as) is + 47 -> state42 err (i:as) is + 48 -> state42 err (i:as) is + 49 -> state42 err (i:as) is + 50 -> state42 err (i:as) is + _ -> err as iis + +start69 :: Lexer +start69 is = state69 (\ as is -> gotError as is) "" is +state69 :: LexerState +state69 err as [] = err as [] +state69 err as iis@(i:is) = + case cclass i of + 15 -> state70 err (i:as) is + 16 -> state70 err (i:as) is + 17 -> state70 err (i:as) is + _ -> err as iis + +start70 :: Lexer +start70 is = state70 (\ as is -> gotError as is) "" is +state70 :: LexerState +state70 err as [] = err as [] +state70 err as iis@(i:is) = + case cclass i of + 15 -> state70 err (i:as) is + 16 -> state70 err (i:as) is + 17 -> state70 err (i:as) is + 10 -> state43 err (i:as) is + _ -> err as iis + +start71 :: Lexer +start71 is = state71 (\ as is -> gotError as is) "" is +state71 :: LexerState +state71 err as [] = err as [] +state71 err as iis@(i:is) = + case cclass i of + 15 -> state72 err (i:as) is + 16 -> state72 err (i:as) is + 17 -> state72 err (i:as) is + 18 -> state72 err (i:as) is + 24 -> state72 err (i:as) is + 25 -> state72 err (i:as) is + 26 -> state72 err (i:as) is + 27 -> state72 err (i:as) is + 28 -> state72 err (i:as) is + 29 -> state72 err (i:as) is + 51 -> state72 err (i:as) is + 52 -> state72 err (i:as) is + 53 -> state72 err (i:as) is + 54 -> state72 err (i:as) is + 55 -> state72 err (i:as) is + 56 -> state72 err (i:as) is + _ -> err as iis + +start72 :: Lexer +start72 is = state72 (\ as is -> gotError as is) "" is +state72 :: LexerState +state72 err as [] = err as [] +state72 err as iis@(i:is) = + case cclass i of + 15 -> state72 err (i:as) is + 16 -> state72 err (i:as) is + 17 -> state72 err (i:as) is + 18 -> state72 err (i:as) is + 24 -> state72 err (i:as) is + 25 -> state72 err (i:as) is + 26 -> state72 err (i:as) is + 27 -> state72 err (i:as) is + 28 -> state72 err (i:as) is + 29 -> state72 err (i:as) is + 51 -> state72 err (i:as) is + 52 -> state72 err (i:as) is + 53 -> state72 err (i:as) is + 54 -> state72 err (i:as) is + 55 -> state72 err (i:as) is + 56 -> state72 err (i:as) is + 10 -> state43 err (i:as) is + _ -> err as iis + +state73 :: LexerState +state73 err as is = output Special as (start1 is) + +state74 :: LexerState +state74 err as [] = err as [] + where err _ _ = output Varsym as (start1 []) +state74 err as iis@(i:is) = + case cclass i of + 7 -> state4 err (i:as) is + 9 -> state4 err (i:as) is + 12 -> state4 err (i:as) is + 14 -> state4 err (i:as) is + 19 -> state4 err (i:as) is + 20 -> state4 err (i:as) is + 21 -> state4 err (i:as) is + 23 -> state4 err (i:as) is + 48 -> state4 err (i:as) is + 49 -> state4 err (i:as) is + 75 -> state4 err (i:as) is + 13 -> state75 err (i:as) is + 22 -> state79 err (i:as) is + _ -> err as iis + where err _ _ = output Varsym as (start1 iis) + +state75 :: LexerState +state75 err as [] = err as [] + where err _ _ = output Commentstart as (start76 []) +state75 err as iis@(i:is) = + case cclass i of + 7 -> state4 err (i:as) is + 9 -> state4 err (i:as) is + 12 -> state4 err (i:as) is + 14 -> state4 err (i:as) is + 19 -> state4 err (i:as) is + 20 -> state4 err (i:as) is + 21 -> state4 err (i:as) is + 22 -> state4 err (i:as) is + 23 -> state4 err (i:as) is + 48 -> state4 err (i:as) is + 49 -> state4 err (i:as) is + 75 -> state4 err (i:as) is + 13 -> state75 err (i:as) is + _ -> err as iis + where err _ _ = output Commentstart as (start76 iis) + +start76 :: Lexer +start76 is = state76 (\ as is -> gotError as is) "" is +state76 :: LexerState +state76 err as [] = err as [] +state76 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 3 -> err as iis + 2 -> state77 err (i:as) is + 4 -> state77 err (i:as) is + 5 -> state78 err (i:as) is + _ -> state76 err (i:as) is + +state77 :: LexerState +state77 err as is = output Comment as (start1 is) + +state78 :: LexerState +state78 err as [] = err as [] + where err _ _ = output Comment as (start1 []) +state78 err as iis@(i:is) = + case cclass i of + 2 -> state77 err (i:as) is + _ -> err as iis + where err _ _ = output Comment as (start1 iis) + +state79 :: LexerState +state79 err as [] = err as [] + where err _ _ = output Reservedop as (start1 []) +state79 err as iis@(i:is) = + case cclass i of + 7 -> state4 err (i:as) is + 9 -> state4 err (i:as) is + 12 -> state4 err (i:as) is + 13 -> state4 err (i:as) is + 14 -> state4 err (i:as) is + 19 -> state4 err (i:as) is + 20 -> state4 err (i:as) is + 21 -> state4 err (i:as) is + 22 -> state4 err (i:as) is + 23 -> state4 err (i:as) is + 48 -> state4 err (i:as) is + 49 -> state4 err (i:as) is + 75 -> state4 err (i:as) is + _ -> err as iis + where err _ _ = output Reservedop as (start1 iis) + +state80 :: LexerState +state80 err as [] = err as [] + where err _ _ = output Varsym as (start1 []) +state80 err as iis@(i:is) = + case cclass i of + 7 -> state4 err (i:as) is + 9 -> state4 err (i:as) is + 12 -> state4 err (i:as) is + 13 -> state4 err (i:as) is + 19 -> state4 err (i:as) is + 20 -> state4 err (i:as) is + 21 -> state4 err (i:as) is + 22 -> state4 err (i:as) is + 23 -> state4 err (i:as) is + 48 -> state4 err (i:as) is + 49 -> state4 err (i:as) is + 75 -> state4 err (i:as) is + 14 -> state79 err (i:as) is + _ -> err as iis + where err _ _ = output Varsym as (start1 iis) + +state81 :: LexerState +state81 err as [] = err as [] + where err _ _ = output IntLit as (start1 []) +state81 err as iis@(i:is) = + case cclass i of + 15 -> state87 err (i:as) is + 16 -> state87 err (i:as) is + 17 -> state87 err (i:as) is + 18 -> state87 err (i:as) is + 38 -> state88 err (i:as) is + 64 -> state88 err (i:as) is + 45 -> state90 err (i:as) is + 72 -> state90 err (i:as) is + 14 -> state82 err (i:as) is + _ -> err as iis + where err _ _ = output IntLit as (start1 iis) + +start82 :: Lexer +start82 is = state82 (\ as is -> gotError as is) "" is +state82 :: LexerState +state82 err as [] = err as [] +state82 err as iis@(i:is) = + case cclass i of + 15 -> state83 err (i:as) is + 16 -> state83 err (i:as) is + 17 -> state83 err (i:as) is + 18 -> state83 err (i:as) is + _ -> err as iis + +state83 :: LexerState +state83 err as [] = err as [] + where err _ _ = output FloatLit as (start1 []) +state83 err as iis@(i:is) = + case cclass i of + 15 -> state83 err (i:as) is + 16 -> state83 err (i:as) is + 17 -> state83 err (i:as) is + 18 -> state83 err (i:as) is + 28 -> state84 err (i:as) is + 55 -> state84 err (i:as) is + _ -> err as iis + where err _ _ = output FloatLit as (start1 iis) + +start84 :: Lexer +start84 is = state84 (\ as is -> gotError as is) "" is +state84 :: LexerState +state84 err as [] = err as [] +state84 err as iis@(i:is) = + case cclass i of + 15 -> state86 err (i:as) is + 16 -> state86 err (i:as) is + 17 -> state86 err (i:as) is + 18 -> state86 err (i:as) is + 12 -> state85 err (i:as) is + 13 -> state85 err (i:as) is + _ -> err as iis + +start85 :: Lexer +start85 is = state85 (\ as is -> gotError as is) "" is +state85 :: LexerState +state85 err as [] = err as [] +state85 err as iis@(i:is) = + case cclass i of + 15 -> state86 err (i:as) is + 16 -> state86 err (i:as) is + 17 -> state86 err (i:as) is + 18 -> state86 err (i:as) is + _ -> err as iis + +state86 :: LexerState +state86 err as [] = err as [] + where err _ _ = output FloatLit as (start1 []) +state86 err as iis@(i:is) = + case cclass i of + 15 -> state86 err (i:as) is + 16 -> state86 err (i:as) is + 17 -> state86 err (i:as) is + 18 -> state86 err (i:as) is + _ -> err as iis + where err _ _ = output FloatLit as (start1 iis) + +state87 :: LexerState +state87 err as [] = err as [] + where err _ _ = output IntLit as (start1 []) +state87 err as iis@(i:is) = + case cclass i of + 15 -> state87 err (i:as) is + 16 -> state87 err (i:as) is + 17 -> state87 err (i:as) is + 18 -> state87 err (i:as) is + 14 -> state82 err (i:as) is + _ -> err as iis + where err _ _ = output IntLit as (start1 iis) + +start88 :: Lexer +start88 is = state88 (\ as is -> gotError as is) "" is +state88 :: LexerState +state88 err as [] = err as [] +state88 err as iis@(i:is) = + case cclass i of + 15 -> state89 err (i:as) is + 16 -> state89 err (i:as) is + 17 -> state89 err (i:as) is + _ -> err as iis + +state89 :: LexerState +state89 err as [] = err as [] + where err _ _ = output IntLit as (start1 []) +state89 err as iis@(i:is) = + case cclass i of + 15 -> state89 err (i:as) is + 16 -> state89 err (i:as) is + 17 -> state89 err (i:as) is + _ -> err as iis + where err _ _ = output IntLit as (start1 iis) + +start90 :: Lexer +start90 is = state90 (\ as is -> gotError as is) "" is +state90 :: LexerState +state90 err as [] = err as [] +state90 err as iis@(i:is) = + case cclass i of + 15 -> state91 err (i:as) is + 16 -> state91 err (i:as) is + 17 -> state91 err (i:as) is + 18 -> state91 err (i:as) is + 24 -> state91 err (i:as) is + 25 -> state91 err (i:as) is + 26 -> state91 err (i:as) is + 27 -> state91 err (i:as) is + 28 -> state91 err (i:as) is + 29 -> state91 err (i:as) is + 51 -> state91 err (i:as) is + 52 -> state91 err (i:as) is + 53 -> state91 err (i:as) is + 54 -> state91 err (i:as) is + 55 -> state91 err (i:as) is + 56 -> state91 err (i:as) is + _ -> err as iis + +state91 :: LexerState +state91 err as [] = err as [] + where err _ _ = output IntLit as (start1 []) +state91 err as iis@(i:is) = + case cclass i of + 15 -> state91 err (i:as) is + 16 -> state91 err (i:as) is + 17 -> state91 err (i:as) is + 18 -> state91 err (i:as) is + 24 -> state91 err (i:as) is + 25 -> state91 err (i:as) is + 26 -> state91 err (i:as) is + 27 -> state91 err (i:as) is + 28 -> state91 err (i:as) is + 29 -> state91 err (i:as) is + 51 -> state91 err (i:as) is + 52 -> state91 err (i:as) is + 53 -> state91 err (i:as) is + 54 -> state91 err (i:as) is + 55 -> state91 err (i:as) is + 56 -> state91 err (i:as) is + _ -> err as iis + where err _ _ = output IntLit as (start1 iis) + +state92 :: LexerState +state92 err as [] = err as [] + where err _ _ = output Reservedop as (start1 []) +state92 err as iis@(i:is) = + case cclass i of + 7 -> state93 err (i:as) is + 9 -> state93 err (i:as) is + 12 -> state93 err (i:as) is + 13 -> state93 err (i:as) is + 14 -> state93 err (i:as) is + 20 -> state93 err (i:as) is + 21 -> state93 err (i:as) is + 22 -> state93 err (i:as) is + 23 -> state93 err (i:as) is + 48 -> state93 err (i:as) is + 49 -> state93 err (i:as) is + 75 -> state93 err (i:as) is + 19 -> state94 err (i:as) is + _ -> err as iis + where err _ _ = output Reservedop as (start1 iis) + +state93 :: LexerState +state93 err as [] = err as [] + where err _ _ = output Consym as (start1 []) +state93 err as iis@(i:is) = + case cclass i of + 7 -> state93 err (i:as) is + 9 -> state93 err (i:as) is + 12 -> state93 err (i:as) is + 13 -> state93 err (i:as) is + 14 -> state93 err (i:as) is + 19 -> state93 err (i:as) is + 20 -> state93 err (i:as) is + 21 -> state93 err (i:as) is + 22 -> state93 err (i:as) is + 23 -> state93 err (i:as) is + 48 -> state93 err (i:as) is + 49 -> state93 err (i:as) is + 75 -> state93 err (i:as) is + _ -> err as iis + where err _ _ = output Consym as (start1 iis) + +state94 :: LexerState +state94 err as [] = err as [] + where err _ _ = output Reservedop as (start1 []) +state94 err as iis@(i:is) = + case cclass i of + 7 -> state93 err (i:as) is + 9 -> state93 err (i:as) is + 12 -> state93 err (i:as) is + 13 -> state93 err (i:as) is + 14 -> state93 err (i:as) is + 19 -> state93 err (i:as) is + 20 -> state93 err (i:as) is + 21 -> state93 err (i:as) is + 22 -> state93 err (i:as) is + 23 -> state93 err (i:as) is + 48 -> state93 err (i:as) is + 49 -> state93 err (i:as) is + 75 -> state93 err (i:as) is + _ -> err as iis + where err _ _ = output Reservedop as (start1 iis) + +state95 :: LexerState +state95 err as [] = err as [] + where err _ _ = output Varsym as (start1 []) +state95 err as iis@(i:is) = + case cclass i of + 7 -> state4 err (i:as) is + 9 -> state4 err (i:as) is + 12 -> state4 err (i:as) is + 14 -> state4 err (i:as) is + 19 -> state4 err (i:as) is + 20 -> state4 err (i:as) is + 21 -> state4 err (i:as) is + 22 -> state4 err (i:as) is + 23 -> state4 err (i:as) is + 48 -> state4 err (i:as) is + 49 -> state4 err (i:as) is + 75 -> state4 err (i:as) is + 13 -> state79 err (i:as) is + _ -> err as iis + where err _ _ = output Varsym as (start1 iis) + +state96 :: LexerState +state96 err as [] = err as [] + where err _ _ = output Reservedop as (start1 []) +state96 err as iis@(i:is) = + case cclass i of + 7 -> state4 err (i:as) is + 9 -> state4 err (i:as) is + 12 -> state4 err (i:as) is + 13 -> state4 err (i:as) is + 14 -> state4 err (i:as) is + 19 -> state4 err (i:as) is + 20 -> state4 err (i:as) is + 21 -> state4 err (i:as) is + 23 -> state4 err (i:as) is + 48 -> state4 err (i:as) is + 49 -> state4 err (i:as) is + 75 -> state4 err (i:as) is + 22 -> state79 err (i:as) is + _ -> err as iis + where err _ _ = output Reservedop as (start1 iis) + +state97 :: LexerState +state97 err as [] = err as [] + where err _ _ = output Conid as (start1 []) +state97 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 14 -> state98 err (i:as) is + _ -> state97 err (i:as) is + where err _ _ = output Conid as (start1 iis) + +start98 :: Lexer +start98 is = state98 (\ as is -> gotError as is) "" is +state98 :: LexerState +state98 err as [] = err as [] +state98 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 8 -> err as iis + 10 -> err as iis + 11 -> err as iis + 15 -> err as iis + 16 -> err as iis + 17 -> err as iis + 18 -> err as iis + 47 -> err as iis + 74 -> err as iis + 76 -> err as iis + 51 -> state111 err (i:as) is + 52 -> state111 err (i:as) is + 56 -> state111 err (i:as) is + 57 -> state111 err (i:as) is + 58 -> state111 err (i:as) is + 60 -> state111 err (i:as) is + 65 -> state111 err (i:as) is + 66 -> state111 err (i:as) is + 67 -> state111 err (i:as) is + 69 -> state111 err (i:as) is + 70 -> state111 err (i:as) is + 72 -> state111 err (i:as) is + 73 -> state111 err (i:as) is + 7 -> state99 err (i:as) is + 9 -> state99 err (i:as) is + 12 -> state99 err (i:as) is + 22 -> state99 err (i:as) is + 49 -> state99 err (i:as) is + 23 -> state102 err (i:as) is + 48 -> state102 err (i:as) is + 75 -> state102 err (i:as) is + 13 -> state100 err (i:as) is + 14 -> state103 err (i:as) is + 19 -> state104 err (i:as) is + 20 -> state107 err (i:as) is + 21 -> state108 err (i:as) is + 50 -> state110 err (i:as) is + 53 -> state112 err (i:as) is + 54 -> state118 err (i:as) is + 55 -> state131 err (i:as) is + 59 -> state132 err (i:as) is + 61 -> state144 err (i:as) is + 62 -> state145 err (i:as) is + 63 -> state149 err (i:as) is + 64 -> state154 err (i:as) is + 68 -> state155 err (i:as) is + 71 -> state158 err (i:as) is + _ -> state109 err (i:as) is + +state99 :: LexerState +state99 err as [] = err as [] + where err _ _ = output Qvarsym as (start1 []) +state99 err as iis@(i:is) = + case cclass i of + 7 -> state99 err (i:as) is + 9 -> state99 err (i:as) is + 12 -> state99 err (i:as) is + 13 -> state99 err (i:as) is + 14 -> state99 err (i:as) is + 19 -> state99 err (i:as) is + 20 -> state99 err (i:as) is + 21 -> state99 err (i:as) is + 22 -> state99 err (i:as) is + 23 -> state99 err (i:as) is + 48 -> state99 err (i:as) is + 49 -> state99 err (i:as) is + 75 -> state99 err (i:as) is + _ -> err as iis + where err _ _ = output Qvarsym as (start1 iis) + +state100 :: LexerState +state100 err as [] = err as [] + where err _ _ = output Qvarsym as (start1 []) +state100 err as iis@(i:is) = + case cclass i of + 7 -> state99 err (i:as) is + 9 -> state99 err (i:as) is + 12 -> state99 err (i:as) is + 14 -> state99 err (i:as) is + 19 -> state99 err (i:as) is + 20 -> state99 err (i:as) is + 21 -> state99 err (i:as) is + 23 -> state99 err (i:as) is + 48 -> state99 err (i:as) is + 49 -> state99 err (i:as) is + 75 -> state99 err (i:as) is + 13 -> state101 err (i:as) is + 22 -> state102 err (i:as) is + _ -> err as iis + where err _ _ = output Qvarsym as (start1 iis) + +start101 :: Lexer +start101 is = state101 (\ as is -> gotError as is) "" is +state101 :: LexerState +state101 err as [] = err as [] +state101 err as iis@(i:is) = + case cclass i of + 7 -> state99 err (i:as) is + 9 -> state99 err (i:as) is + 12 -> state99 err (i:as) is + 14 -> state99 err (i:as) is + 19 -> state99 err (i:as) is + 20 -> state99 err (i:as) is + 21 -> state99 err (i:as) is + 22 -> state99 err (i:as) is + 23 -> state99 err (i:as) is + 48 -> state99 err (i:as) is + 49 -> state99 err (i:as) is + 75 -> state99 err (i:as) is + 13 -> state101 err (i:as) is + _ -> err as iis + +start102 :: Lexer +start102 is = state102 (\ as is -> gotError as is) "" is +state102 :: LexerState +state102 err as [] = err as [] +state102 err as iis@(i:is) = + case cclass i of + 7 -> state99 err (i:as) is + 9 -> state99 err (i:as) is + 12 -> state99 err (i:as) is + 13 -> state99 err (i:as) is + 14 -> state99 err (i:as) is + 19 -> state99 err (i:as) is + 20 -> state99 err (i:as) is + 21 -> state99 err (i:as) is + 22 -> state99 err (i:as) is + 23 -> state99 err (i:as) is + 48 -> state99 err (i:as) is + 49 -> state99 err (i:as) is + 75 -> state99 err (i:as) is + _ -> err as iis + +state103 :: LexerState +state103 err as [] = err as [] + where err _ _ = output Qvarsym as (start1 []) +state103 err as iis@(i:is) = + case cclass i of + 7 -> state99 err (i:as) is + 9 -> state99 err (i:as) is + 12 -> state99 err (i:as) is + 13 -> state99 err (i:as) is + 19 -> state99 err (i:as) is + 20 -> state99 err (i:as) is + 21 -> state99 err (i:as) is + 22 -> state99 err (i:as) is + 23 -> state99 err (i:as) is + 48 -> state99 err (i:as) is + 49 -> state99 err (i:as) is + 75 -> state99 err (i:as) is + 14 -> state102 err (i:as) is + _ -> err as iis + where err _ _ = output Qvarsym as (start1 iis) + +start104 :: Lexer +start104 is = state104 (\ as is -> gotError as is) "" is +state104 :: LexerState +state104 err as [] = err as [] +state104 err as iis@(i:is) = + case cclass i of + 7 -> state105 err (i:as) is + 9 -> state105 err (i:as) is + 12 -> state105 err (i:as) is + 13 -> state105 err (i:as) is + 14 -> state105 err (i:as) is + 20 -> state105 err (i:as) is + 21 -> state105 err (i:as) is + 22 -> state105 err (i:as) is + 23 -> state105 err (i:as) is + 48 -> state105 err (i:as) is + 49 -> state105 err (i:as) is + 75 -> state105 err (i:as) is + 19 -> state106 err (i:as) is + _ -> err as iis + +state105 :: LexerState +state105 err as [] = err as [] + where err _ _ = output Qconsym as (start1 []) +state105 err as iis@(i:is) = + case cclass i of + 7 -> state105 err (i:as) is + 9 -> state105 err (i:as) is + 12 -> state105 err (i:as) is + 13 -> state105 err (i:as) is + 14 -> state105 err (i:as) is + 19 -> state105 err (i:as) is + 20 -> state105 err (i:as) is + 21 -> state105 err (i:as) is + 22 -> state105 err (i:as) is + 23 -> state105 err (i:as) is + 48 -> state105 err (i:as) is + 49 -> state105 err (i:as) is + 75 -> state105 err (i:as) is + _ -> err as iis + where err _ _ = output Qconsym as (start1 iis) + +start106 :: Lexer +start106 is = state106 (\ as is -> gotError as is) "" is +state106 :: LexerState +state106 err as [] = err as [] +state106 err as iis@(i:is) = + case cclass i of + 7 -> state105 err (i:as) is + 9 -> state105 err (i:as) is + 12 -> state105 err (i:as) is + 13 -> state105 err (i:as) is + 14 -> state105 err (i:as) is + 19 -> state105 err (i:as) is + 20 -> state105 err (i:as) is + 21 -> state105 err (i:as) is + 22 -> state105 err (i:as) is + 23 -> state105 err (i:as) is + 48 -> state105 err (i:as) is + 49 -> state105 err (i:as) is + 75 -> state105 err (i:as) is + _ -> err as iis + +state107 :: LexerState +state107 err as [] = err as [] + where err _ _ = output Qvarsym as (start1 []) +state107 err as iis@(i:is) = + case cclass i of + 7 -> state99 err (i:as) is + 9 -> state99 err (i:as) is + 12 -> state99 err (i:as) is + 14 -> state99 err (i:as) is + 19 -> state99 err (i:as) is + 20 -> state99 err (i:as) is + 21 -> state99 err (i:as) is + 22 -> state99 err (i:as) is + 23 -> state99 err (i:as) is + 48 -> state99 err (i:as) is + 49 -> state99 err (i:as) is + 75 -> state99 err (i:as) is + 13 -> state102 err (i:as) is + _ -> err as iis + where err _ _ = output Qvarsym as (start1 iis) + +start108 :: Lexer +start108 is = state108 (\ as is -> gotError as is) "" is +state108 :: LexerState +state108 err as [] = err as [] +state108 err as iis@(i:is) = + case cclass i of + 7 -> state99 err (i:as) is + 9 -> state99 err (i:as) is + 12 -> state99 err (i:as) is + 13 -> state99 err (i:as) is + 14 -> state99 err (i:as) is + 19 -> state99 err (i:as) is + 20 -> state99 err (i:as) is + 21 -> state99 err (i:as) is + 23 -> state99 err (i:as) is + 48 -> state99 err (i:as) is + 49 -> state99 err (i:as) is + 75 -> state99 err (i:as) is + 22 -> state102 err (i:as) is + _ -> err as iis + +state109 :: LexerState +state109 err as [] = err as [] + where err _ _ = output Qconid as (start1 []) +state109 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 14 -> state98 err (i:as) is + _ -> state109 err (i:as) is + where err _ _ = output Qconid as (start1 iis) + +start110 :: Lexer +start110 is = state110 (\ as is -> gotError as is) "" is +state110 :: LexerState +state110 err as [] = err as [] +state110 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + _ -> state111 err (i:as) is + +state111 :: LexerState +state111 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state111 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state112 :: LexerState +state112 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state112 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state113 err (i:as) is + 61 -> state115 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state113 :: LexerState +state113 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state113 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 67 -> state114 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state114 :: LexerState +state114 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state114 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state110 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state115 :: LexerState +state115 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state115 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state116 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state116 :: LexerState +state116 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state116 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 67 -> state117 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state117 :: LexerState +state117 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state117 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 67 -> state110 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state118 :: LexerState +state118 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state118 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 64 -> state110 err (i:as) is + 51 -> state119 err (i:as) is + 55 -> state121 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state119 :: LexerState +state119 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state119 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 68 -> state120 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state120 :: LexerState +state120 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state120 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state110 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state121 :: LexerState +state121 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state121 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 56 -> state122 err (i:as) is + 66 -> state126 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state122 :: LexerState +state122 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state122 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state123 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state123 :: LexerState +state123 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state123 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 69 -> state124 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state124 :: LexerState +state124 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state124 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 61 -> state125 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state125 :: LexerState +state125 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state125 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 68 -> state110 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state126 :: LexerState +state126 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state126 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 59 -> state127 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state127 :: LexerState +state127 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state127 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 70 -> state128 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state128 :: LexerState +state128 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state128 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 59 -> state129 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state129 :: LexerState +state129 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state129 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 63 -> state130 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state130 :: LexerState +state130 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state130 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 57 -> state110 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state131 :: LexerState +state131 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state131 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 61 -> state113 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state132 :: LexerState +state132 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state132 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 56 -> state110 err (i:as) is + 62 -> state133 err (i:as) is + 63 -> state136 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state133 :: LexerState +state133 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state133 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 65 -> state134 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state134 :: LexerState +state134 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state134 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 64 -> state135 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state135 :: LexerState +state135 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state135 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 66 -> state125 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +start136 :: Lexer +start136 is = state136 (\ as is -> gotError as is) "" is +state136 :: LexerState +state136 err as [] = err as [] +state136 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 56 -> state137 err (i:as) is + 67 -> state140 err (i:as) is + _ -> state111 err (i:as) is + +state137 :: LexerState +state137 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state137 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 59 -> state138 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state138 :: LexerState +state138 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state138 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 72 -> state139 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +start139 :: Lexer +start139 is = state139 (\ as is -> gotError as is) "" is +state139 :: LexerState +state139 err as [] = err as [] +state139 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 61 -> state110 err (i:as) is + 66 -> state110 err (i:as) is + _ -> state111 err (i:as) is + +state140 :: LexerState +state140 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state140 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 68 -> state141 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state141 :: LexerState +state141 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state141 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state142 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state142 :: LexerState +state142 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state142 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 63 -> state143 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state143 :: LexerState +state143 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state143 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 53 -> state114 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state144 :: LexerState +state144 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state144 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state125 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state145 :: LexerState +state145 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state145 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 64 -> state146 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state146 :: LexerState +state146 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state146 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 54 -> state147 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state147 :: LexerState +state147 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state147 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 69 -> state148 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state148 :: LexerState +state148 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state148 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 61 -> state114 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state149 :: LexerState +state149 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state149 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state150 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state150 :: LexerState +state150 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state150 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 71 -> state151 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state151 :: LexerState +state151 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state151 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 68 -> state152 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state152 :: LexerState +state152 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state152 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 73 -> state153 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state153 :: LexerState +state153 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state153 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 65 -> state114 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state154 :: LexerState +state154 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state154 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 56 -> state110 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state155 :: LexerState +state155 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state155 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 73 -> state153 err (i:as) is + 58 -> state156 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state156 :: LexerState +state156 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state156 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state157 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state157 :: LexerState +state157 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state157 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 63 -> state110 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state158 :: LexerState +state158 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state158 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 58 -> state159 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state159 :: LexerState +state159 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state159 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state160 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state160 :: LexerState +state160 err as [] = err as [] + where err _ _ = output Qvarid as (start1 []) +state160 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 66 -> state114 err (i:as) is + _ -> state111 err (i:as) is + where err _ _ = output Qvarid as (start1 iis) + +state161 :: LexerState +state161 err as [] = err as [] + where err _ _ = output Reservedid as (start1 []) +state161 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + _ -> state162 err (i:as) is + where err _ _ = output Reservedid as (start1 iis) + +state162 :: LexerState +state162 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state162 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state163 :: LexerState +state163 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state163 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state164 err (i:as) is + 61 -> state166 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state164 :: LexerState +state164 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state164 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 67 -> state165 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state165 :: LexerState +state165 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state165 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state161 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state166 :: LexerState +state166 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state166 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state167 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state167 :: LexerState +state167 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state167 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 67 -> state168 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state168 :: LexerState +state168 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state168 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 67 -> state161 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state169 :: LexerState +state169 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state169 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 64 -> state161 err (i:as) is + 51 -> state170 err (i:as) is + 55 -> state172 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state170 :: LexerState +state170 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state170 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 68 -> state171 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state171 :: LexerState +state171 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state171 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state161 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state172 :: LexerState +state172 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state172 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 56 -> state173 err (i:as) is + 66 -> state177 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state173 :: LexerState +state173 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state173 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state174 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state174 :: LexerState +state174 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state174 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 69 -> state175 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state175 :: LexerState +state175 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state175 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 61 -> state176 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state176 :: LexerState +state176 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state176 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 68 -> state161 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state177 :: LexerState +state177 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state177 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 59 -> state178 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state178 :: LexerState +state178 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state178 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 70 -> state179 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state179 :: LexerState +state179 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state179 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 59 -> state180 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state180 :: LexerState +state180 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state180 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 63 -> state181 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state181 :: LexerState +state181 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state181 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 57 -> state161 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state182 :: LexerState +state182 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state182 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 61 -> state164 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state183 :: LexerState +state183 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state183 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 56 -> state161 err (i:as) is + 62 -> state184 err (i:as) is + 63 -> state187 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state184 :: LexerState +state184 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state184 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 65 -> state185 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state185 :: LexerState +state185 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state185 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 64 -> state186 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state186 :: LexerState +state186 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state186 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 66 -> state176 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state187 :: LexerState +state187 err as [] = err as [] + where err _ _ = output Reservedid as (start1 []) +state187 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 56 -> state188 err (i:as) is + 67 -> state191 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Reservedid as (start1 iis) + +state188 :: LexerState +state188 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state188 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 59 -> state189 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state189 :: LexerState +state189 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state189 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 72 -> state190 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state190 :: LexerState +state190 err as [] = err as [] + where err _ _ = output Reservedid as (start1 []) +state190 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 61 -> state161 err (i:as) is + 66 -> state161 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Reservedid as (start1 iis) + +state191 :: LexerState +state191 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state191 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 68 -> state192 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state192 :: LexerState +state192 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state192 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 51 -> state193 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state193 :: LexerState +state193 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state193 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 63 -> state194 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state194 :: LexerState +state194 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state194 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 53 -> state165 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state195 :: LexerState +state195 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state195 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state176 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state196 :: LexerState +state196 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state196 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 64 -> state197 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state197 :: LexerState +state197 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state197 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 54 -> state198 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state198 :: LexerState +state198 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state198 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 69 -> state199 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state199 :: LexerState +state199 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state199 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 61 -> state165 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state200 :: LexerState +state200 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state200 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state201 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state201 :: LexerState +state201 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state201 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 71 -> state202 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state202 :: LexerState +state202 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state202 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 68 -> state203 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state203 :: LexerState +state203 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state203 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 73 -> state204 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state204 :: LexerState +state204 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state204 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 65 -> state165 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state205 :: LexerState +state205 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state205 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 56 -> state161 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state206 :: LexerState +state206 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state206 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 73 -> state204 err (i:as) is + 58 -> state207 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state207 :: LexerState +state207 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state207 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state208 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state208 :: LexerState +state208 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state208 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 63 -> state161 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state209 :: LexerState +state209 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state209 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 58 -> state210 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state210 :: LexerState +state210 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state210 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 55 -> state211 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state211 :: LexerState +state211 err as [] = err as [] + where err _ _ = output Varid as (start1 []) +state211 err as iis@(i:is) = + case cclass i of + 0 -> err as iis + 1 -> err as iis + 2 -> err as iis + 3 -> err as iis + 4 -> err as iis + 5 -> err as iis + 6 -> err as iis + 7 -> err as iis + 8 -> err as iis + 9 -> err as iis + 11 -> err as iis + 12 -> err as iis + 13 -> err as iis + 14 -> err as iis + 19 -> err as iis + 20 -> err as iis + 21 -> err as iis + 22 -> err as iis + 23 -> err as iis + 47 -> err as iis + 48 -> err as iis + 49 -> err as iis + 74 -> err as iis + 75 -> err as iis + 76 -> err as iis + 66 -> state165 err (i:as) is + _ -> state162 err (i:as) is + where err _ _ = output Varid as (start1 iis) + +state212 :: LexerState +state212 err as [] = err as [] + where err _ _ = output Special as (start1 []) +state212 err as iis@(i:is) = + case cclass i of + 13 -> state213 err (i:as) is + _ -> err as iis + where err _ _ = output Special as (start1 iis) + +state213 :: LexerState +state213 err as is = nestedComment as is state214 + +state214 :: LexerState +state214 err as is = output NestedComment as (start1 is) + + diff --git a/src/lexer/HsLexUtils.hs b/src/lexer/HsLexUtils.hs new file mode 100644 --- /dev/null +++ b/src/lexer/HsLexUtils.hs @@ -0,0 +1,37 @@ +module HsLexUtils(module HsLexUtils,Token(..)) where +import HsTokens + +gotEOF [] = [] +gotEOF as = [(GotEOF, reverse as)] + +gotError as is = + (ErrorToken, reverse as): + if null is then [(GotEOF,[])] else [(TheRest,is{-reverse (take 80 is)-})] + +-- Inlining the call to output does not make a big difference. +--output token as cont = (token, reverse as):cont + +-- Not reversing the token string seems to save about 10% of the time with HBC. +-- The difference in speed seems insignificant with ghc-6.0.1 -O. +output token as cont = (token,reverse as):cont + +-- This avoids constructing a closure for the call to reverse. +-- This saves about 10% too. +{- +output token as cont = + rev as [] + where + rev [] as' = (token,as'):cont + rev (a:as) as' = rev as (a:as') +--} + +nestedComment as is next = nest 0 as is + where + nest n as is = + case is of + '-':'}':is -> if n==0 + then next gotError ('}':'-':as) is + else nest (n-1) ('}':'-':as) is + '{':'-':is -> nest (n+1) ('-':'{':as) is + c:is -> nest n (c:as) is + _ -> gotError as is -- EOF inside comment diff --git a/src/lexer/HsLexerPass1.hs b/src/lexer/HsLexerPass1.hs new file mode 100644 --- /dev/null +++ b/src/lexer/HsLexerPass1.hs @@ -0,0 +1,54 @@ +module HsLexerPass1(module HsLexerPass1,module HsLexerPos) where +import HsLex(haskellLex) +import HsLexUtils +import HsLayoutPre(layoutPre,PosToken) +import HsLexerPos +import Data.List(mapAccumL) + +default(Int) + +{-+ +The function #lexerPass1# handles the part of lexical analysis that +can be done independently of the parser, i.e., the tokenization and the +addition of the extra layout tokens <n> and {n}, as specified in +section 9.3 of the revised Haskell 98 Report. +-} + +type LexerOutput = [PosToken] +type Lexer = String -> LexerOutput + +lexerPass1 :: Lexer +lexerPass1 = lexerPass1Only . lexerPass0 + +lexerPass1Only = layoutPre . rmSpace + +rmSpace = filter (notWhite.fst) + +notWhite t = t/=Whitespace && + t/=Commentstart && t/=Comment && + t/=NestedComment + +-- Tokenize and add position information: + +lexerPass0 :: Lexer +lexerPass0 = lexerPass0' startPos + +lexerPass0' :: Pos -> Lexer +lexerPass0' pos0 = addPos . haskellLex . rmcr + where + addPos = snd . mapAccumL pos pos0 + + pos p (t,s) = {-seq p'-} (p',(t,(p,s))) + where p' = nextPos p s +-- where s = reverse r + +{-+ +Since #nextPos# examines one character at a time, it will increase the line +number by 2 if it sees \CR\LF, which can happen when reading DOS files on +a Unix like system. +Since the extra \CR characters can cause trouble later as well, we choose +to simply remove them here. +-} +rmcr ('\CR':'\LF':s) = '\LF':rmcr s +rmcr (c:s) = c:rmcr s +rmcr "" = "" diff --git a/src/lexer/HsLexerPos.hs b/src/lexer/HsLexerPos.hs new file mode 100644 --- /dev/null +++ b/src/lexer/HsLexerPos.hs @@ -0,0 +1,34 @@ +module HsLexerPos where + +data Pos = Pos { char, line, column :: !Int } deriving (Show) + +simpPos (Pos _ l c) = (l,c) + +-- Some functions still put fake char positions in Pos values, so... +instance Eq Pos where p1 == p2 = simpPos p1 == simpPos p2 +instance Ord Pos where compare p1 p2 = compare (simpPos p1) (simpPos p2) + + +startPos = Pos { char=0, + line=1, + column=1 -- The first column is designated column 1, not 0. + } + +nextPos :: Pos -> String -> Pos +nextPos = foldl nextPos1 + +nextPos1 :: Pos -> Char -> Pos +nextPos1 (Pos n y x) c = + case c of + -- The characters newline, return, linefeed, and formfeed, all start + -- a new line. + '\n' -> Pos (n+1) (y+1) 1 + '\CR' -> Pos (n+1) (y+1) 1 + '\LF' -> Pos (n+1) (y+1) 1 + '\FF' -> Pos (n+1) (y+1) 1 + -- Tab stops are 8 characters apart. + -- A tab character causes the insertion of enough spaces to align the + -- current position with the next tab stop. + -- + (not in the report) the first tab stop is column 1. + '\t' -> Pos (n+1) y (x+8-(x-1) `mod` 8) + _ -> Pos (n+1) y (x+1) diff --git a/src/lexer/HsTokens.hs b/src/lexer/HsTokens.hs new file mode 100644 --- /dev/null +++ b/src/lexer/HsTokens.hs @@ -0,0 +1,27 @@ +module HsTokens where + +-- Haskell token classifications: + +data Token + = Varid | Conid | Varsym | Consym + | Reservedid | Reservedop | Specialid + | IntLit | FloatLit | CharLit | StringLit + | Qvarid | Qconid | Qvarsym | Qconsym + | Special | Whitespace + + | NestedCommentStart -- will cause a call to an external function + | NestedComment -- from the external function + | LiterateComment -- not handled by the lexer + + | Commentstart -- dashes + | Comment -- what follows the dashes + + | ErrorToken | GotEOF | TheRest + + | ModuleName | ModuleAlias -- recognized in a later pass + + -- Inserted during layout processing (see Haskell 98, 9.3): + | Layout -- for implicit braces + | Indent Int -- , to preceed first token on each line + | Open Int -- {n}, after let, where, do or of, if not followed by a "{" + deriving (Show,Eq,Ord)