• Home
• com.yahoo.vespa
• schema-language-server
• 8.439.22
• source code
• IndexingParserLexer.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

ai.vespa.schemals.parser.indexinglanguage.IndexingParserLexer Maven / Gradle / Ivy

/* Generated by: CongoCC Parser Generator. IndexingParserLexer.java  */
package ai.vespa.schemals.parser.indexinglanguage;

import ai.vespa.schemals.parser.indexinglanguage.Token.TokenType;
import static ai.vespa.schemals.parser.indexinglanguage.Token.TokenType.*;
import java.util.*;


public class IndexingParserLexer extends TokenSource {

    public static EnumSet getRegularTokens() {
        return EnumSet.copyOf(regularTokens);
    }

    private static MatcherHook MATCHER_HOOK;

    // this cannot be initialize here, since hook must be set afterwards
    public enum LexicalState {
        DEFAULT
    }

    LexicalState lexicalState = LexicalState.values()[0];
    EnumSet activeTokenTypes = null;
    // Token types that are "regular" tokens that participate in parsing,
    // i.e. declared as TOKEN
    static final EnumSet regularTokens = EnumSet.of(EOF, NL, ADD, SUB, MUL, DIV, MOD, EQ, NE, LT, LE, GT, GE, CHOICE, PIPE, LCURLY, RCURLY, LPAREN, RPAREN, DOT, COMMA, COLON, SCOLON, ATTRIBUTE, BASE64_DECODE, BASE64_ENCODE, BINARIZE, BUSY_WAIT, CASE, CASE_DEFAULT, CLEAR_STATE, CREATE_IF_NON_EXISTENT, ECHO, ELSE, EMBED, EXACT, FLATTEN, FOR_EACH, GET_FIELD, GET_VAR, GUARD, HASH, HEX_DECODE, HEX_ENCODE, HOST_NAME, IF, INDEX, INPUT, JOIN, LOWER_CASE, MAX_LENGTH, MAX_OCCURRENCES, MAX_TOKEN_LENGTH, NGRAM, NORMALIZE, NOW, OPTIMIZE_PREDICATE, PACK_BITS, PASSTHROUGH, RANDOM, REMOVE_IF_ZERO, SELECT_INPUT, SET_LANGUAGE, SET_VAR, SLEEP, SPLIT, STEM, SUBSTRING, SUMMARY, SWITCH, THIS, TOKENIZE, TO_ARRAY, TO_BYTE, TO_DOUBLE, TO_FLOAT, TO_INT, TO_LONG, TO_POS, TO_EPOCH_SECOND, TO_STRING, TO_WSET, TO_BOOL, TRIM, ZCURVE, TRUE, FALSE, UNDERSCORE, INTEGER, LONG, DOUBLE, FLOAT, STRING, IDENTIFIER);
    // Token types that do not participate in parsing
    // i.e. declared as UNPARSED (or SPECIAL_TOKEN)
    static final EnumSet unparsedTokens = EnumSet.of(COMMENT);
    // Tokens that are skipped, i.e. SKIP
    static final EnumSet skippedTokens = EnumSet.of(_TOKEN_1, _TOKEN_2, _TOKEN_3, _TOKEN_4);
    // Tokens that correspond to a MORE, i.e. that are pending
    // additional input
    static final EnumSet moreTokens = EnumSet.noneOf(TokenType.class);

    public IndexingParserLexer(CharSequence input) {
        this("input", input);
    }

    /**
    * @param inputSource just the name of the input source (typically the filename)
    * that will be used in error messages and so on.
    * @param input the input
    */
    public IndexingParserLexer(String inputSource, CharSequence input) {
        this(inputSource, input, LexicalState.DEFAULT, 1, 1);
    }

    /**
    * @param inputSource just the name of the input source (typically the filename) that
    * will be used in error messages and so on.
    * @param input the input
    * @param lexicalState The starting lexical state, may be null to indicate the default
    * starting state
    * @param line The line number at which we are starting for the purposes of location/error messages. In most
    * normal usage, this is 1.
    * @param column number at which we are starting for the purposes of location/error messages. In most normal
    * usages this is 1.
    */
    public IndexingParserLexer(String inputSource, CharSequence input, LexicalState lexState, int startingLine, int startingColumn) {
        super(inputSource, input, startingLine, startingColumn, 1, true, false, false, "");
        if (lexicalState != null) switchTo(lexState);
    }

    public Token getNextToken(Token tok) {
        return getNextToken(tok, this.activeTokenTypes);
    }

    /**
    * The public method for getting the next token, that is
    * called by IndexingParser.
    * It checks whether we have already cached
    * the token after this one. If not, it finally goes
    * to the NFA machinery
    */
    public Token getNextToken(Token tok, EnumSet activeTokenTypes) {
        if (tok == null) {
            tok = tokenizeAt(0, null, activeTokenTypes);
            cacheToken(tok);
            return tok;
        }
        Token cachedToken = tok.nextCachedToken();
        // If the cached next token is not currently active, we
        // throw it away and go back to the IndexingParserLexer
        if (cachedToken != null && activeTokenTypes != null && !activeTokenTypes.contains(cachedToken.getType())) {
            reset(tok);
            cachedToken = null;
        }
        if (cachedToken == null) {
            Token token = tokenizeAt(tok.getEndOffset(), null, activeTokenTypes);
            cacheToken(token);
            return token;
        }
        return cachedToken;
    }


    static class MatchInfo {
        TokenType matchedType;
        int matchLength;

        @Override
        public int hashCode() {
            return Objects.hash(matchLength, matchedType);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null) return false;
            if (getClass() != obj.getClass()) return false;
            MatchInfo other = (MatchInfo) obj;
            return matchLength == other.matchLength && matchedType == other.matchedType;
        }

    }


    @FunctionalInterface
    private interface MatcherHook {

        MatchInfo apply(LexicalState lexicalState, CharSequence input, int position, EnumSet activeTokenTypes, NfaFunction[] nfaFunctions, BitSet currentStates, BitSet nextStates, MatchInfo matchInfo);

    }


    /**
    * Core tokenization method. Note that this can be called from a static context.
    * Hence the extra parameters that need to be passed in.
    */
    static MatchInfo getMatchInfo(CharSequence input, int position, EnumSet activeTokenTypes, NfaFunction[] nfaFunctions, BitSet currentStates, BitSet nextStates, MatchInfo matchInfo) {
        if (matchInfo == null) {
            matchInfo = new MatchInfo();
        }
        if (position >= input.length()) {
            matchInfo.matchedType = EOF;
            matchInfo.matchLength = 0;
            return matchInfo;
        }
        int start = position;
        int matchLength = 0;
        TokenType matchedType = TokenType.INVALID;
        EnumSet alreadyMatchedTypes = EnumSet.noneOf(TokenType.class);
        if (currentStates == null) currentStates = new BitSet(574);
        else currentStates.clear();
        if (nextStates == null) nextStates = new BitSet(574);
        else nextStates.clear();
        // the core NFA loop
        do {
            // Holder for the new type (if any) matched on this iteration
            if (position > start) {
                // What was nextStates on the last iteration
                // is now the currentStates!
                BitSet temp = currentStates;
                currentStates = nextStates;
                nextStates = temp;
                nextStates.clear();
            } else {
                currentStates.set(0);
            }
            if (position >= input.length()) {
                break;
            }
            int curChar = Character.codePointAt(input, position++);
            if (curChar > 0xFFFF) position++;
            int nextActive = currentStates.nextSetBit(0);
            while (nextActive != -1) {
                TokenType returnedType = nfaFunctions[nextActive].apply(curChar, nextStates, activeTokenTypes, alreadyMatchedTypes);
                if (returnedType != null && (position - start > matchLength || returnedType.ordinal() < matchedType.ordinal())) {
                    matchedType = returnedType;
                    matchLength = position - start;
                    alreadyMatchedTypes.add(returnedType);
                }
                nextActive = currentStates.nextSetBit(nextActive + 1);
            }
            if (position >= input.length()) break;
        }
        while (!nextStates.isEmpty());
        matchInfo.matchedType = matchedType;
        matchInfo.matchLength = matchLength;
        return matchInfo;
    }

    /**
    * @param position The position at which to tokenize.
    * @param lexicalState The lexical state in which to tokenize. If this is null, it is the instance variable #lexicalState
    * @param activeTokenTypes The active token types. If this is null, they are all active.
    * @return the Token at position
    */
    final Token tokenizeAt(int position, LexicalState lexicalState, EnumSet activeTokenTypes) {
        if (lexicalState == null) lexicalState = this.lexicalState;
        int tokenBeginOffset = position;
        boolean inMore = false;
        int invalidRegionStart = -1;
        Token matchedToken = null;
        TokenType matchedType = null;
        // The core tokenization loop
        MatchInfo matchInfo = new MatchInfo();
        BitSet currentStates = new BitSet(574);
        BitSet nextStates = new BitSet(574);
        while (matchedToken == null) {
            if (!inMore) tokenBeginOffset = position;
            if (MATCHER_HOOK != null) {
                matchInfo = MATCHER_HOOK.apply(lexicalState, this, position, activeTokenTypes, nfaFunctions, currentStates, nextStates, matchInfo);
                if (matchInfo == null) {
                    matchInfo = getMatchInfo(this, position, activeTokenTypes, nfaFunctions, currentStates, nextStates, matchInfo);
                }
            } else {
                matchInfo = getMatchInfo(this, position, activeTokenTypes, nfaFunctions, currentStates, nextStates, matchInfo);
            }
            matchedType = matchInfo.matchedType;
            inMore = moreTokens.contains(matchedType);
            position += matchInfo.matchLength;
            if (matchedType == TokenType.INVALID) {
                if (invalidRegionStart == -1) {
                    invalidRegionStart = tokenBeginOffset;
                }
                int cp = Character.codePointAt(this, position);
                ++position;
                if (cp > 0xFFFF) ++position;
                continue;
            }
            if (invalidRegionStart != -1) {
                return new InvalidToken(this, invalidRegionStart, tokenBeginOffset);
            }
            if (skippedTokens.contains(matchedType)) {
                skipTokens(tokenBeginOffset, position);
            } else if (regularTokens.contains(matchedType) || unparsedTokens.contains(matchedType)) {
                matchedToken = Token.newToken(matchedType, this, tokenBeginOffset, position);
                matchedToken.setUnparsed(!regularTokens.contains(matchedType));
            }
        }
        return matchedToken;
    }

    /**
    * Switch to specified lexical state.
    * @param lexState the lexical state to switch to
    * @return whether we switched (i.e. we weren't already in the desired lexical state)
    */
    public boolean switchTo(LexicalState lexState) {
        if (this.lexicalState != lexState) {
            this.lexicalState = lexState;
            return true;
        }
        return false;
    }

    // Reset the token source input
    // to just after the Token passed in.
    void reset(Token t, LexicalState state) {
        uncacheTokens(t);
        if (state != null) {
            switchTo(state);
        }
    }

    void reset(Token t) {
        reset(t, null);
    }


    // NFA related code follows.
    // The functional interface that represents
    // the acceptance method of an NFA state
    @FunctionalInterface
    interface NfaFunction {

        TokenType apply(int ch, BitSet bs, EnumSet validTypes, EnumSet alreadyMatchedTypes);

    }

    private static NfaFunction[] nfaFunctions;
    // Initialize the various NFA method tables
    static {
        DEFAULT.NFA_FUNCTIONS_init();
    }

    //The Nitty-gritty of the NFA code follows.
    /**
    * Holder class for NFA code related to DEFAULT lexical state
    */
    private static class DEFAULT {

        private static TokenType getNfaIndex0(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if (ch == '!') {
                if (validTypes == null || validTypes.contains(NE)) {
                    nextStates.set(47);
                }
            } else if (ch == '"') {
                if (validTypes == null || validTypes.contains(STRING)) {
                    nextStates.set(58);
                }
            } else if (ch == '\'') {
                if (validTypes == null || validTypes.contains(STRING)) {
                    nextStates.set(38);
                }
            } else if (ch == '0') {
                if (validTypes == null || validTypes.contains(LONG)) {
                    nextStates.set(97);
                }
                if (validTypes == null || validTypes.contains(INTEGER)) {
                    nextStates.set(226);
                }
            }
            if (ch >= '0' && ch <= '9') {
                if (validTypes == null || validTypes.contains(FLOAT)) {
                    nextStates.set(73);
                }
                if (validTypes == null || validTypes.contains(LONG)) {
                    nextStates.set(80);
                }
            } else if (ch == '<') {
                if (validTypes == null || validTypes.contains(LE)) {
                    nextStates.set(76);
                }
            } else if (ch == '=') {
                if (validTypes == null || validTypes.contains(EQ)) {
                    nextStates.set(55);
                }
            } else if (ch == '>') {
                if (validTypes == null || validTypes.contains(GE)) {
                    nextStates.set(4);
                }
            } else if (ch == 'a') {
                if (validTypes == null || validTypes.contains(ATTRIBUTE)) {
                    nextStates.set(348);
                }
            } else if (ch == 'b') {
                if (validTypes == null || validTypes.contains(BASE64_ENCODE)) {
                    nextStates.set(237);
                }
                if (validTypes == null || validTypes.contains(BASE64_DECODE)) {
                    nextStates.set(287);
                }
                if (validTypes == null || validTypes.contains(BUSY_WAIT)) {
                    nextStates.set(355);
                }
                if (validTypes == null || validTypes.contains(BINARIZE)) {
                    nextStates.set(379);
                }
            } else if (ch == 'c') {
                if (validTypes == null || validTypes.contains(CLEAR_STATE)) {
                    nextStates.set(227);
                }
                if (validTypes == null || validTypes.contains(CREATE_IF_NON_EXISTENT)) {
                    nextStates.set(249);
                }
                if (validTypes == null || validTypes.contains(CASE)) {
                    nextStates.set(444);
                }
            } else if (ch == 'd') {
                if (validTypes == null || validTypes.contains(CASE_DEFAULT)) {
                    nextStates.set(197);
                }
            } else if (ch == 'e') {
                if (validTypes == null || validTypes.contains(EXACT)) {
                    nextStates.set(109);
                }
                if (validTypes == null || validTypes.contains(ECHO)) {
                    nextStates.set(114);
                }
                if (validTypes == null || validTypes.contains(ELSE)) {
                    nextStates.set(116);
                }
                if (validTypes == null || validTypes.contains(EMBED)) {
                    nextStates.set(301);
                }
            } else if (ch == 'f') {
                if (validTypes == null || validTypes.contains(FOR_EACH)) {
                    nextStates.set(99);
                }
                if (validTypes == null || validTypes.contains(FLATTEN)) {
                    nextStates.set(154);
                }
                if (validTypes == null || validTypes.contains(FALSE)) {
                    nextStates.set(335);
                }
            } else if (ch == 'g') {
                if (validTypes == null || validTypes.contains(GET_FIELD)) {
                    nextStates.set(328);
                }
                if (validTypes == null || validTypes.contains(GET_VAR)) {
                    nextStates.set(385);
                }
                if (validTypes == null || validTypes.contains(GUARD)) {
                    nextStates.set(446);
                }
            } else if (ch == 'h') {
                if (validTypes == null || validTypes.contains(HEX_DECODE)) {
                    nextStates.set(206);
                }
                if (validTypes == null || validTypes.contains(HOST_NAME)) {
                    nextStates.set(281);
                }
                if (validTypes == null || validTypes.contains(HEX_ENCODE)) {
                    nextStates.set(435);
                }
                if (validTypes == null || validTypes.contains(HASH)) {
                    nextStates.set(452);
                }
            } else if (ch == 'i') {
                if (validTypes == null || validTypes.contains(IF)) {
                    nextStates.set(9);
                }
                if (validTypes == null || validTypes.contains(INPUT)) {
                    nextStates.set(189);
                }
                if (validTypes == null || validTypes.contains(INDEX)) {
                    nextStates.set(449);
                }
            } else if (ch == 'j') {
                if (validTypes == null || validTypes.contains(JOIN)) {
                    nextStates.set(112);
                }
            } else if (ch == 'l') {
                if (validTypes == null || validTypes.contains(LOWER_CASE)) {
                    nextStates.set(390);
                }
            } else if (ch == 'm') {
                if (validTypes == null || validTypes.contains(MAX_LENGTH)) {
                    nextStates.set(178);
                }
                if (validTypes == null || validTypes.contains(MAX_OCCURRENCES)) {
                    nextStates.set(310);
                }
                if (validTypes == null || validTypes.contains(MAX_TOKEN_LENGTH)) {
                    nextStates.set(408);
                }
            } else if (ch == 'n') {
                if (validTypes == null || validTypes.contains(NOW)) {
                    nextStates.set(126);
                }
                if (validTypes == null || validTypes.contains(NGRAM)) {
                    nextStates.set(186);
                }
                if (validTypes == null || validTypes.contains(NORMALIZE)) {
                    nextStates.set(269);
                }
            } else if (ch == 'o') {
                if (validTypes == null || validTypes.contains(OPTIMIZE_PREDICATE)) {
                    nextStates.set(129);
                }
            } else if (ch == 'p') {
                if (validTypes == null || validTypes.contains(PACK_BITS)) {
                    nextStates.set(338);
                }
                if (validTypes == null || validTypes.contains(PASSTHROUGH)) {
                    nextStates.set(397);
                }
            } else if (ch == 'r') {
                if (validTypes == null || validTypes.contains(REMOVE_IF_ZERO)) {
                    nextStates.set(85);
                }
                if (validTypes == null || validTypes.contains(RANDOM)) {
                    nextStates.set(105);
                }
            } else if (ch == 's') {
                if (validTypes == null || validTypes.contains(SPLIT)) {
                    nextStates.set(118);
                }
                if (validTypes == null || validTypes.contains(SLEEP)) {
                    nextStates.set(170);
                }
                if (validTypes == null || validTypes.contains(SET_VAR)) {
                    nextStates.set(192);
                }
                if (validTypes == null || validTypes.contains(SWITCH)) {
                    nextStates.set(297);
                }
                if (validTypes == null || validTypes.contains(SUMMARY)) {
                    nextStates.set(323);
                }
                if (validTypes == null || validTypes.contains(SET_LANGUAGE)) {
                    nextStates.set(362);
                }
                if (validTypes == null || validTypes.contains(SUBSTRING)) {
                    nextStates.set(372);
                }
                if (validTypes == null || validTypes.contains(STEM)) {
                    nextStates.set(406);
                }
                if (validTypes == null || validTypes.contains(SELECT_INPUT)) {
                    nextStates.set(460);
                }
            } else if (ch == 't') {
                if (validTypes == null || validTypes.contains(TO_WSET)) {
                    nextStates.set(121);
                }
                if (validTypes == null || validTypes.contains(THIS)) {
                    nextStates.set(127);
                }
                if (validTypes == null || validTypes.contains(TO_BYTE)) {
                    nextStates.set(145);
                }
                if (validTypes == null || validTypes.contains(TO_POS)) {
                    nextStates.set(150);
                }
                if (validTypes == null || validTypes.contains(TO_STRING)) {
                    nextStates.set(159);
                }
                if (validTypes == null || validTypes.contains(TO_INT)) {
                    nextStates.set(166);
                }
                if (validTypes == null || validTypes.contains(TO_BOOL)) {
                    nextStates.set(173);
                }
                if (validTypes == null || validTypes.contains(TO_EPOCH_SECOND)) {
                    nextStates.set(213);
                }
                if (validTypes == null || validTypes.contains(TRIM)) {
                    nextStates.set(247);
                }
                if (validTypes == null || validTypes.contains(TO_LONG)) {
                    nextStates.set(276);
                }
                if (validTypes == null || validTypes.contains(TOKENIZE)) {
                    nextStates.set(304);
                }
                if (validTypes == null || validTypes.contains(TRUE)) {
                    nextStates.set(346);
                }
                if (validTypes == null || validTypes.contains(TO_ARRAY)) {
                    nextStates.set(422);
                }
                if (validTypes == null || validTypes.contains(TO_DOUBLE)) {
                    nextStates.set(428);
                }
                if (validTypes == null || validTypes.contains(TO_FLOAT)) {
                    nextStates.set(454);
                }
            } else if (ch == 'z') {
                if (validTypes == null || validTypes.contains(ZCURVE)) {
                    nextStates.set(202);
                }
            } else if (ch == '|') {
                if (validTypes == null || validTypes.contains(CHOICE)) {
                    nextStates.set(18);
                }
            }
            if ((ch >= 'A' && ch <= 'Z') || ((ch == '_') || (ch >= 'a' && ch <= 'z'))) {
                if (validTypes == null || validTypes.contains(IDENTIFIER)) {
                    nextStates.set(46);
                    type = IDENTIFIER;
                }
            } else if (ch >= '0' && ch <= '9') {
                if (validTypes == null || validTypes.contains(DOUBLE)) {
                    nextStates.set(13);
                }
                if (validTypes == null || validTypes.contains(INTEGER)) {
                    nextStates.set(39);
                    type = INTEGER;
                }
            } else if (ch == '#') {
                if (validTypes == null || validTypes.contains(COMMENT)) {
                    nextStates.set(77);
                    type = COMMENT;
                }
            }
            if (ch == '_') {
                if (validTypes == null || validTypes.contains(UNDERSCORE)) {
                    type = UNDERSCORE;
                }
            } else if (ch == ';') {
                if (validTypes == null || validTypes.contains(SCOLON)) {
                    type = SCOLON;
                }
            } else if (ch == ':') {
                if (validTypes == null || validTypes.contains(COLON)) {
                    type = COLON;
                }
            } else if (ch == ',') {
                if (validTypes == null || validTypes.contains(COMMA)) {
                    type = COMMA;
                }
            } else if (ch == '.') {
                if (validTypes == null || validTypes.contains(DOT)) {
                    type = DOT;
                }
            } else if (ch == ')') {
                if (validTypes == null || validTypes.contains(RPAREN)) {
                    type = RPAREN;
                }
            } else if (ch == '(') {
                if (validTypes == null || validTypes.contains(LPAREN)) {
                    type = LPAREN;
                }
            } else if (ch == '}') {
                if (validTypes == null || validTypes.contains(RCURLY)) {
                    type = RCURLY;
                }
            } else if (ch == '{') {
                if (validTypes == null || validTypes.contains(LCURLY)) {
                    type = LCURLY;
                }
            } else if (ch == '|') {
                if (validTypes == null || validTypes.contains(PIPE)) {
                    type = PIPE;
                }
            } else if (ch == '>') {
                if (validTypes == null || validTypes.contains(GT)) {
                    type = GT;
                }
            } else if (ch == '<') {
                if (validTypes == null || validTypes.contains(LT)) {
                    type = LT;
                }
            } else if (ch == '%') {
                if (validTypes == null || validTypes.contains(MOD)) {
                    type = MOD;
                }
            } else if (ch == '/') {
                if (validTypes == null || validTypes.contains(DIV)) {
                    type = DIV;
                }
            } else if (ch == '*') {
                if (validTypes == null || validTypes.contains(MUL)) {
                    type = MUL;
                }
            } else if (ch == '-') {
                if (validTypes == null || validTypes.contains(SUB)) {
                    type = SUB;
                }
            } else if (ch == '+') {
                if (validTypes == null || validTypes.contains(ADD)) {
                    type = ADD;
                }
            } else if (ch == '\n') {
                if (validTypes == null || validTypes.contains(NL)) {
                    type = NL;
                }
            } else if (ch == '\f') {
                if (validTypes == null || validTypes.contains(_TOKEN_4)) {
                    type = _TOKEN_4;
                }
            } else if (ch == '\r') {
                if (validTypes == null || validTypes.contains(_TOKEN_3)) {
                    type = _TOKEN_3;
                }
            } else if (ch == '\t') {
                if (validTypes == null || validTypes.contains(_TOKEN_2)) {
                    type = _TOKEN_2;
                }
            } else if (ch == ' ') {
                if (validTypes == null || validTypes.contains(_TOKEN_1)) {
                    type = _TOKEN_1;
                }
            }
            return type;
        }

        private static TokenType getNfaIndex1(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                return REMOVE_IF_ZERO;
            }
            return null;
        }

        private static TokenType getNfaIndex2(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if ((ch >= '0' && ch <= '9') || ((ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f'))) {
                nextStates.set(2);
            } else if ((ch == 'L') || (ch == 'l')) {
                type = LONG;
            }
            return type;
        }

        private static TokenType getNfaIndex3(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                return FOR_EACH;
            }
            return null;
        }

        private static TokenType getNfaIndex4(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '=') {
                return GE;
            }
            return null;
        }

        private static TokenType getNfaIndex5(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                return RANDOM;
            }
            return null;
        }

        private static TokenType getNfaIndex6(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return EXACT;
            }
            return null;
        }

        private static TokenType getNfaIndex7(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                return JOIN;
            }
            return null;
        }

        private static TokenType getNfaIndex8(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                return ECHO;
            }
            return null;
        }

        private static TokenType getNfaIndex9(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'f') {
                return IF;
            }
            return null;
        }

        private static TokenType getNfaIndex10(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return ELSE;
            }
            return null;
        }

        private static TokenType getNfaIndex11(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return SPLIT;
            }
            return null;
        }

        private static TokenType getNfaIndex12(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return TO_WSET;
            }
            return null;
        }

        private static TokenType getNfaIndex13(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if ((ch == 'E') || (ch == 'e')) {
                nextStates.set(14);
            } else if (ch == '.') {
                nextStates.set(16);
                type = DOUBLE;
            } else if (ch >= '0' && ch <= '9') {
                nextStates.set(13);
                type = DOUBLE;
            }
            return type;
        }

        private static TokenType getNfaIndex14(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if ((ch == '+') || (ch == '-')) {
                nextStates.set(15);
            } else if (ch >= '0' && ch <= '9') {
                nextStates.set(15);
                type = DOUBLE;
            }
            return type;
        }

        private static TokenType getNfaIndex15(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch >= '0' && ch <= '9') {
                nextStates.set(15);
                return DOUBLE;
            }
            return null;
        }

        private static TokenType getNfaIndex16(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if ((ch == 'E') || (ch == 'e')) {
                nextStates.set(14);
            } else if (ch >= '0' && ch <= '9') {
                nextStates.set(16);
                type = DOUBLE;
            }
            return type;
        }

        private static TokenType getNfaIndex17(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'w') {
                return NOW;
            }
            return null;
        }

        private static TokenType getNfaIndex18(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '|') {
                return CHOICE;
            }
            return null;
        }

        private static TokenType getNfaIndex19(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                return THIS;
            }
            return null;
        }

        private static TokenType getNfaIndex20(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return OPTIMIZE_PREDICATE;
            }
            return null;
        }

        private static TokenType getNfaIndex21(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return TO_BYTE;
            }
            return null;
        }

        private static TokenType getNfaIndex22(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                return TO_POS;
            }
            return null;
        }

        private static TokenType getNfaIndex23(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                return FLATTEN;
            }
            return null;
        }

        private static TokenType getNfaIndex24(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                return TO_STRING;
            }
            return null;
        }

        private static TokenType getNfaIndex25(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return TO_INT;
            }
            return null;
        }

        private static TokenType getNfaIndex26(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'p') {
                return SLEEP;
            }
            return null;
        }

        private static TokenType getNfaIndex27(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                return TO_BOOL;
            }
            return null;
        }

        private static TokenType getNfaIndex28(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                return MAX_LENGTH;
            }
            return null;
        }

        private static TokenType getNfaIndex29(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                return NGRAM;
            }
            return null;
        }

        private static TokenType getNfaIndex30(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return INPUT;
            }
            return null;
        }

        private static TokenType getNfaIndex31(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                return SET_VAR;
            }
            return null;
        }

        private static TokenType getNfaIndex32(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return CASE_DEFAULT;
            }
            return null;
        }

        private static TokenType getNfaIndex33(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return ZCURVE;
            }
            return null;
        }

        private static TokenType getNfaIndex34(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return HEX_DECODE;
            }
            return null;
        }

        private static TokenType getNfaIndex35(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                return TO_EPOCH_SECOND;
            }
            return null;
        }

        private static TokenType getNfaIndex36(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if ((ch >= '0' && ch <= '9') || ((ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f'))) {
                nextStates.set(36);
                return INTEGER;
            }
            return null;
        }

        private static TokenType getNfaIndex37(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return CLEAR_STATE;
            }
            return null;
        }

        private static TokenType getNfaIndex38(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if ((ch >= 0x0 && ch <= '&') || (ch >= '(')) {
                nextStates.set(38);
            }
            if (ch == '\\') {
                nextStates.set(236);
            } else if (ch == '\'') {
                type = STRING;
            }
            return type;
        }

        private static TokenType getNfaIndex39(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch >= '0' && ch <= '9') {
                nextStates.set(39);
                return INTEGER;
            }
            return null;
        }

        private static TokenType getNfaIndex40(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return BASE64_ENCODE;
            }
            return null;
        }

        private static TokenType getNfaIndex41(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                return TRIM;
            }
            return null;
        }

        private static TokenType getNfaIndex42(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return CREATE_IF_NON_EXISTENT;
            }
            return null;
        }

        private static TokenType getNfaIndex43(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return NORMALIZE;
            }
            return null;
        }

        private static TokenType getNfaIndex44(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                return TO_LONG;
            }
            return null;
        }

        private static TokenType getNfaIndex45(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return HOST_NAME;
            }
            return null;
        }

        private static TokenType getNfaIndex46(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if ((ch == '-') || ((ch >= '0' && ch <= '9') || ((ch >= 'A' && ch <= 'Z') || ((ch == '_') || (ch >= 'a' && ch <= 'z'))))) {
                nextStates.set(46);
                return IDENTIFIER;
            }
            return null;
        }

        private static TokenType getNfaIndex47(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '=') {
                return NE;
            }
            return null;
        }

        private static TokenType getNfaIndex48(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return BASE64_DECODE;
            }
            return null;
        }

        private static TokenType getNfaIndex49(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                return SWITCH;
            }
            return null;
        }

        private static TokenType getNfaIndex50(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                return EMBED;
            }
            return null;
        }

        private static TokenType getNfaIndex51(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return TOKENIZE;
            }
            return null;
        }

        private static TokenType getNfaIndex52(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                return MAX_OCCURRENCES;
            }
            return null;
        }

        private static TokenType getNfaIndex53(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'y') {
                return SUMMARY;
            }
            return null;
        }

        private static TokenType getNfaIndex54(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                return GET_FIELD;
            }
            return null;
        }

        private static TokenType getNfaIndex55(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '=') {
                return EQ;
            }
            return null;
        }

        private static TokenType getNfaIndex56(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return FALSE;
            }
            return null;
        }

        private static TokenType getNfaIndex57(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                return PACK_BITS;
            }
            return null;
        }

        private static TokenType getNfaIndex58(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if ((ch >= 0x0 && ch <= '!') || (ch >= '#')) {
                nextStates.set(58);
            }
            if (ch == '\\') {
                nextStates.set(345);
            } else if (ch == '"') {
                type = STRING;
            }
            return type;
        }

        private static TokenType getNfaIndex59(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return TRUE;
            }
            return null;
        }

        private static TokenType getNfaIndex60(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return ATTRIBUTE;
            }
            return null;
        }

        private static TokenType getNfaIndex61(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return BUSY_WAIT;
            }
            return null;
        }

        private static TokenType getNfaIndex62(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return SET_LANGUAGE;
            }
            return null;
        }

        private static TokenType getNfaIndex63(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                return SUBSTRING;
            }
            return null;
        }

        private static TokenType getNfaIndex64(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return BINARIZE;
            }
            return null;
        }

        private static TokenType getNfaIndex65(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                return GET_VAR;
            }
            return null;
        }

        private static TokenType getNfaIndex66(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return LOWER_CASE;
            }
            return null;
        }

        private static TokenType getNfaIndex67(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                return PASSTHROUGH;
            }
            return null;
        }

        private static TokenType getNfaIndex68(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                return STEM;
            }
            return null;
        }

        private static TokenType getNfaIndex69(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                return MAX_TOKEN_LENGTH;
            }
            return null;
        }

        private static TokenType getNfaIndex70(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'y') {
                return TO_ARRAY;
            }
            return null;
        }

        private static TokenType getNfaIndex71(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return TO_DOUBLE;
            }
            return null;
        }

        private static TokenType getNfaIndex72(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return HEX_ENCODE;
            }
            return null;
        }

        private static TokenType getNfaIndex73(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if (ch == '.') {
                nextStates.set(75);
            } else if (ch >= '0' && ch <= '9') {
                nextStates.set(73);
            } else if ((ch == 'E') || (ch == 'e')) {
                nextStates.set(442);
            } else if ((ch == 'F') || (ch == 'f')) {
                type = FLOAT;
            }
            return type;
        }

        private static TokenType getNfaIndex74(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if (ch >= '0' && ch <= '9') {
                nextStates.set(74);
            } else if ((ch == 'F') || (ch == 'f')) {
                type = FLOAT;
            }
            return type;
        }

        private static TokenType getNfaIndex75(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if (ch >= '0' && ch <= '9') {
                nextStates.set(75);
            } else if ((ch == 'E') || (ch == 'e')) {
                nextStates.set(442);
            } else if ((ch == 'F') || (ch == 'f')) {
                type = FLOAT;
            }
            return type;
        }

        private static TokenType getNfaIndex76(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '=') {
                return LE;
            }
            return null;
        }

        private static TokenType getNfaIndex77(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if ((ch >= 0x0 && ch <= '\t') || ((ch == 0xb || ch == '\f') || (ch >= 0xe))) {
                nextStates.set(77);
                return COMMENT;
            }
            return null;
        }

        private static TokenType getNfaIndex78(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                return CASE;
            }
            return null;
        }

        private static TokenType getNfaIndex79(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                return GUARD;
            }
            return null;
        }

        private static TokenType getNfaIndex80(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            TokenType type = null;
            if (ch >= '0' && ch <= '9') {
                nextStates.set(80);
            } else if ((ch == 'L') || (ch == 'l')) {
                type = LONG;
            }
            return type;
        }

        private static TokenType getNfaIndex81(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'x') {
                return INDEX;
            }
            return null;
        }

        private static TokenType getNfaIndex82(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                return HASH;
            }
            return null;
        }

        private static TokenType getNfaIndex83(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return TO_FLOAT;
            }
            return null;
        }

        private static TokenType getNfaIndex84(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                return SELECT_INPUT;
            }
            return null;
        }

        private static TokenType getNfaIndex85(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(86);
            }
            return null;
        }

        private static TokenType getNfaIndex86(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                nextStates.set(87);
            }
            return null;
        }

        private static TokenType getNfaIndex87(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(88);
            }
            return null;
        }

        private static TokenType getNfaIndex88(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'v') {
                nextStates.set(89);
            }
            return null;
        }

        private static TokenType getNfaIndex89(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(90);
            }
            return null;
        }

        private static TokenType getNfaIndex90(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(91);
            }
            return null;
        }

        private static TokenType getNfaIndex91(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(92);
            }
            return null;
        }

        private static TokenType getNfaIndex92(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'f') {
                nextStates.set(93);
            }
            return null;
        }

        private static TokenType getNfaIndex93(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(94);
            }
            return null;
        }

        private static TokenType getNfaIndex94(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'z') {
                nextStates.set(95);
            }
            return null;
        }

        private static TokenType getNfaIndex95(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(96);
            }
            return null;
        }

        private static TokenType getNfaIndex96(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(1);
            }
            return null;
        }

        private static TokenType getNfaIndex97(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if ((ch == 'X') || (ch == 'x')) {
                nextStates.set(98);
            }
            return null;
        }

        private static TokenType getNfaIndex98(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if ((ch >= '0' && ch <= '9') || ((ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f'))) {
                nextStates.set(2);
            }
            return null;
        }

        private static TokenType getNfaIndex99(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(100);
            }
            return null;
        }

        private static TokenType getNfaIndex100(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(101);
            }
            return null;
        }

        private static TokenType getNfaIndex101(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(102);
            }
            return null;
        }

        private static TokenType getNfaIndex102(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(103);
            }
            return null;
        }

        private static TokenType getNfaIndex103(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(104);
            }
            return null;
        }

        private static TokenType getNfaIndex104(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(3);
            }
            return null;
        }

        private static TokenType getNfaIndex105(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(106);
            }
            return null;
        }

        private static TokenType getNfaIndex106(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(107);
            }
            return null;
        }

        private static TokenType getNfaIndex107(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(108);
            }
            return null;
        }

        private static TokenType getNfaIndex108(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(5);
            }
            return null;
        }

        private static TokenType getNfaIndex109(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'x') {
                nextStates.set(110);
            }
            return null;
        }

        private static TokenType getNfaIndex110(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(111);
            }
            return null;
        }

        private static TokenType getNfaIndex111(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(6);
            }
            return null;
        }

        private static TokenType getNfaIndex112(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(113);
            }
            return null;
        }

        private static TokenType getNfaIndex113(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(7);
            }
            return null;
        }

        private static TokenType getNfaIndex114(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(115);
            }
            return null;
        }

        private static TokenType getNfaIndex115(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                nextStates.set(8);
            }
            return null;
        }

        private static TokenType getNfaIndex116(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(117);
            }
            return null;
        }

        private static TokenType getNfaIndex117(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(10);
            }
            return null;
        }

        private static TokenType getNfaIndex118(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'p') {
                nextStates.set(119);
            }
            return null;
        }

        private static TokenType getNfaIndex119(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(120);
            }
            return null;
        }

        private static TokenType getNfaIndex120(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(11);
            }
            return null;
        }

        private static TokenType getNfaIndex121(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(122);
            }
            return null;
        }

        private static TokenType getNfaIndex122(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(123);
            }
            return null;
        }

        private static TokenType getNfaIndex123(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'w') {
                nextStates.set(124);
            }
            return null;
        }

        private static TokenType getNfaIndex124(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(125);
            }
            return null;
        }

        private static TokenType getNfaIndex125(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(12);
            }
            return null;
        }

        private static TokenType getNfaIndex126(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(17);
            }
            return null;
        }

        private static TokenType getNfaIndex127(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                nextStates.set(128);
            }
            return null;
        }

        private static TokenType getNfaIndex128(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(19);
            }
            return null;
        }

        private static TokenType getNfaIndex129(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'p') {
                nextStates.set(130);
            }
            return null;
        }

        private static TokenType getNfaIndex130(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(131);
            }
            return null;
        }

        private static TokenType getNfaIndex131(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(132);
            }
            return null;
        }

        private static TokenType getNfaIndex132(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                nextStates.set(133);
            }
            return null;
        }

        private static TokenType getNfaIndex133(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(134);
            }
            return null;
        }

        private static TokenType getNfaIndex134(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'z') {
                nextStates.set(135);
            }
            return null;
        }

        private static TokenType getNfaIndex135(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(136);
            }
            return null;
        }

        private static TokenType getNfaIndex136(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(137);
            }
            return null;
        }

        private static TokenType getNfaIndex137(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'p') {
                nextStates.set(138);
            }
            return null;
        }

        private static TokenType getNfaIndex138(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(139);
            }
            return null;
        }

        private static TokenType getNfaIndex139(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(140);
            }
            return null;
        }

        private static TokenType getNfaIndex140(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(141);
            }
            return null;
        }

        private static TokenType getNfaIndex141(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(142);
            }
            return null;
        }

        private static TokenType getNfaIndex142(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(143);
            }
            return null;
        }

        private static TokenType getNfaIndex143(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(144);
            }
            return null;
        }

        private static TokenType getNfaIndex144(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(20);
            }
            return null;
        }

        private static TokenType getNfaIndex145(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(146);
            }
            return null;
        }

        private static TokenType getNfaIndex146(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(147);
            }
            return null;
        }

        private static TokenType getNfaIndex147(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'b') {
                nextStates.set(148);
            }
            return null;
        }

        private static TokenType getNfaIndex148(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'y') {
                nextStates.set(149);
            }
            return null;
        }

        private static TokenType getNfaIndex149(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(21);
            }
            return null;
        }

        private static TokenType getNfaIndex150(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(151);
            }
            return null;
        }

        private static TokenType getNfaIndex151(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(152);
            }
            return null;
        }

        private static TokenType getNfaIndex152(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'p') {
                nextStates.set(153);
            }
            return null;
        }

        private static TokenType getNfaIndex153(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(22);
            }
            return null;
        }

        private static TokenType getNfaIndex154(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(155);
            }
            return null;
        }

        private static TokenType getNfaIndex155(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(156);
            }
            return null;
        }

        private static TokenType getNfaIndex156(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(157);
            }
            return null;
        }

        private static TokenType getNfaIndex157(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(158);
            }
            return null;
        }

        private static TokenType getNfaIndex158(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(23);
            }
            return null;
        }

        private static TokenType getNfaIndex159(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(160);
            }
            return null;
        }

        private static TokenType getNfaIndex160(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(161);
            }
            return null;
        }

        private static TokenType getNfaIndex161(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(162);
            }
            return null;
        }

        private static TokenType getNfaIndex162(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(163);
            }
            return null;
        }

        private static TokenType getNfaIndex163(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(164);
            }
            return null;
        }

        private static TokenType getNfaIndex164(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(165);
            }
            return null;
        }

        private static TokenType getNfaIndex165(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(24);
            }
            return null;
        }

        private static TokenType getNfaIndex166(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(167);
            }
            return null;
        }

        private static TokenType getNfaIndex167(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(168);
            }
            return null;
        }

        private static TokenType getNfaIndex168(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(169);
            }
            return null;
        }

        private static TokenType getNfaIndex169(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(25);
            }
            return null;
        }

        private static TokenType getNfaIndex170(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(171);
            }
            return null;
        }

        private static TokenType getNfaIndex171(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(172);
            }
            return null;
        }

        private static TokenType getNfaIndex172(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(26);
            }
            return null;
        }

        private static TokenType getNfaIndex173(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(174);
            }
            return null;
        }

        private static TokenType getNfaIndex174(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(175);
            }
            return null;
        }

        private static TokenType getNfaIndex175(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'b') {
                nextStates.set(176);
            }
            return null;
        }

        private static TokenType getNfaIndex176(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(177);
            }
            return null;
        }

        private static TokenType getNfaIndex177(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(27);
            }
            return null;
        }

        private static TokenType getNfaIndex178(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(179);
            }
            return null;
        }

        private static TokenType getNfaIndex179(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'x') {
                nextStates.set(180);
            }
            return null;
        }

        private static TokenType getNfaIndex180(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '-') {
                nextStates.set(181);
            }
            return null;
        }

        private static TokenType getNfaIndex181(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(182);
            }
            return null;
        }

        private static TokenType getNfaIndex182(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(183);
            }
            return null;
        }

        private static TokenType getNfaIndex183(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(184);
            }
            return null;
        }

        private static TokenType getNfaIndex184(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                nextStates.set(185);
            }
            return null;
        }

        private static TokenType getNfaIndex185(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(28);
            }
            return null;
        }

        private static TokenType getNfaIndex186(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                nextStates.set(187);
            }
            return null;
        }

        private static TokenType getNfaIndex187(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(188);
            }
            return null;
        }

        private static TokenType getNfaIndex188(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(29);
            }
            return null;
        }

        private static TokenType getNfaIndex189(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(190);
            }
            return null;
        }

        private static TokenType getNfaIndex190(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'p') {
                nextStates.set(191);
            }
            return null;
        }

        private static TokenType getNfaIndex191(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(30);
            }
            return null;
        }

        private static TokenType getNfaIndex192(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(193);
            }
            return null;
        }

        private static TokenType getNfaIndex193(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(194);
            }
            return null;
        }

        private static TokenType getNfaIndex194(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(195);
            }
            return null;
        }

        private static TokenType getNfaIndex195(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'v') {
                nextStates.set(196);
            }
            return null;
        }

        private static TokenType getNfaIndex196(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(31);
            }
            return null;
        }

        private static TokenType getNfaIndex197(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(198);
            }
            return null;
        }

        private static TokenType getNfaIndex198(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'f') {
                nextStates.set(199);
            }
            return null;
        }

        private static TokenType getNfaIndex199(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(200);
            }
            return null;
        }

        private static TokenType getNfaIndex200(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(201);
            }
            return null;
        }

        private static TokenType getNfaIndex201(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(32);
            }
            return null;
        }

        private static TokenType getNfaIndex202(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(203);
            }
            return null;
        }

        private static TokenType getNfaIndex203(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(204);
            }
            return null;
        }

        private static TokenType getNfaIndex204(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(205);
            }
            return null;
        }

        private static TokenType getNfaIndex205(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'v') {
                nextStates.set(33);
            }
            return null;
        }

        private static TokenType getNfaIndex206(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(207);
            }
            return null;
        }

        private static TokenType getNfaIndex207(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'x') {
                nextStates.set(208);
            }
            return null;
        }

        private static TokenType getNfaIndex208(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(209);
            }
            return null;
        }

        private static TokenType getNfaIndex209(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(210);
            }
            return null;
        }

        private static TokenType getNfaIndex210(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(211);
            }
            return null;
        }

        private static TokenType getNfaIndex211(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(212);
            }
            return null;
        }

        private static TokenType getNfaIndex212(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(34);
            }
            return null;
        }

        private static TokenType getNfaIndex213(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(214);
            }
            return null;
        }

        private static TokenType getNfaIndex214(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(215);
            }
            return null;
        }

        private static TokenType getNfaIndex215(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(216);
            }
            return null;
        }

        private static TokenType getNfaIndex216(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'p') {
                nextStates.set(217);
            }
            return null;
        }

        private static TokenType getNfaIndex217(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(218);
            }
            return null;
        }

        private static TokenType getNfaIndex218(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(219);
            }
            return null;
        }

        private static TokenType getNfaIndex219(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                nextStates.set(220);
            }
            return null;
        }

        private static TokenType getNfaIndex220(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(221);
            }
            return null;
        }

        private static TokenType getNfaIndex221(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(222);
            }
            return null;
        }

        private static TokenType getNfaIndex222(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(223);
            }
            return null;
        }

        private static TokenType getNfaIndex223(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(224);
            }
            return null;
        }

        private static TokenType getNfaIndex224(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(225);
            }
            return null;
        }

        private static TokenType getNfaIndex225(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(35);
            }
            return null;
        }

        private static TokenType getNfaIndex226(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if ((ch == 'X') || (ch == 'x')) {
                nextStates.set(36);
            }
            return null;
        }

        private static TokenType getNfaIndex227(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(228);
            }
            return null;
        }

        private static TokenType getNfaIndex228(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(229);
            }
            return null;
        }

        private static TokenType getNfaIndex229(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(230);
            }
            return null;
        }

        private static TokenType getNfaIndex230(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(231);
            }
            return null;
        }

        private static TokenType getNfaIndex231(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(232);
            }
            return null;
        }

        private static TokenType getNfaIndex232(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(233);
            }
            return null;
        }

        private static TokenType getNfaIndex233(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(234);
            }
            return null;
        }

        private static TokenType getNfaIndex234(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(235);
            }
            return null;
        }

        private static TokenType getNfaIndex235(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(37);
            }
            return null;
        }

        private static TokenType getNfaIndex236(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '\'') {
                nextStates.set(38);
            }
            return null;
        }

        private static TokenType getNfaIndex237(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(238);
            }
            return null;
        }

        private static TokenType getNfaIndex238(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(239);
            }
            return null;
        }

        private static TokenType getNfaIndex239(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(240);
            }
            return null;
        }

        private static TokenType getNfaIndex240(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '6') {
                nextStates.set(241);
            }
            return null;
        }

        private static TokenType getNfaIndex241(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '4') {
                nextStates.set(242);
            }
            return null;
        }

        private static TokenType getNfaIndex242(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(243);
            }
            return null;
        }

        private static TokenType getNfaIndex243(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(244);
            }
            return null;
        }

        private static TokenType getNfaIndex244(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(245);
            }
            return null;
        }

        private static TokenType getNfaIndex245(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(246);
            }
            return null;
        }

        private static TokenType getNfaIndex246(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(40);
            }
            return null;
        }

        private static TokenType getNfaIndex247(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(248);
            }
            return null;
        }

        private static TokenType getNfaIndex248(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(41);
            }
            return null;
        }

        private static TokenType getNfaIndex249(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(250);
            }
            return null;
        }

        private static TokenType getNfaIndex250(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(251);
            }
            return null;
        }

        private static TokenType getNfaIndex251(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(252);
            }
            return null;
        }

        private static TokenType getNfaIndex252(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(253);
            }
            return null;
        }

        private static TokenType getNfaIndex253(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(254);
            }
            return null;
        }

        private static TokenType getNfaIndex254(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(255);
            }
            return null;
        }

        private static TokenType getNfaIndex255(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(256);
            }
            return null;
        }

        private static TokenType getNfaIndex256(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'f') {
                nextStates.set(257);
            }
            return null;
        }

        private static TokenType getNfaIndex257(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(258);
            }
            return null;
        }

        private static TokenType getNfaIndex258(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(259);
            }
            return null;
        }

        private static TokenType getNfaIndex259(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(260);
            }
            return null;
        }

        private static TokenType getNfaIndex260(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(261);
            }
            return null;
        }

        private static TokenType getNfaIndex261(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(262);
            }
            return null;
        }

        private static TokenType getNfaIndex262(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(263);
            }
            return null;
        }

        private static TokenType getNfaIndex263(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'x') {
                nextStates.set(264);
            }
            return null;
        }

        private static TokenType getNfaIndex264(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(265);
            }
            return null;
        }

        private static TokenType getNfaIndex265(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(266);
            }
            return null;
        }

        private static TokenType getNfaIndex266(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(267);
            }
            return null;
        }

        private static TokenType getNfaIndex267(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(268);
            }
            return null;
        }

        private static TokenType getNfaIndex268(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(42);
            }
            return null;
        }

        private static TokenType getNfaIndex269(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(270);
            }
            return null;
        }

        private static TokenType getNfaIndex270(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(271);
            }
            return null;
        }

        private static TokenType getNfaIndex271(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                nextStates.set(272);
            }
            return null;
        }

        private static TokenType getNfaIndex272(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(273);
            }
            return null;
        }

        private static TokenType getNfaIndex273(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(274);
            }
            return null;
        }

        private static TokenType getNfaIndex274(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(275);
            }
            return null;
        }

        private static TokenType getNfaIndex275(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'z') {
                nextStates.set(43);
            }
            return null;
        }

        private static TokenType getNfaIndex276(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(277);
            }
            return null;
        }

        private static TokenType getNfaIndex277(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(278);
            }
            return null;
        }

        private static TokenType getNfaIndex278(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(279);
            }
            return null;
        }

        private static TokenType getNfaIndex279(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(280);
            }
            return null;
        }

        private static TokenType getNfaIndex280(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(44);
            }
            return null;
        }

        private static TokenType getNfaIndex281(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(282);
            }
            return null;
        }

        private static TokenType getNfaIndex282(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(283);
            }
            return null;
        }

        private static TokenType getNfaIndex283(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(284);
            }
            return null;
        }

        private static TokenType getNfaIndex284(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(285);
            }
            return null;
        }

        private static TokenType getNfaIndex285(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(286);
            }
            return null;
        }

        private static TokenType getNfaIndex286(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                nextStates.set(45);
            }
            return null;
        }

        private static TokenType getNfaIndex287(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(288);
            }
            return null;
        }

        private static TokenType getNfaIndex288(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(289);
            }
            return null;
        }

        private static TokenType getNfaIndex289(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(290);
            }
            return null;
        }

        private static TokenType getNfaIndex290(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '6') {
                nextStates.set(291);
            }
            return null;
        }

        private static TokenType getNfaIndex291(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '4') {
                nextStates.set(292);
            }
            return null;
        }

        private static TokenType getNfaIndex292(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(293);
            }
            return null;
        }

        private static TokenType getNfaIndex293(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(294);
            }
            return null;
        }

        private static TokenType getNfaIndex294(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(295);
            }
            return null;
        }

        private static TokenType getNfaIndex295(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(296);
            }
            return null;
        }

        private static TokenType getNfaIndex296(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(48);
            }
            return null;
        }

        private static TokenType getNfaIndex297(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'w') {
                nextStates.set(298);
            }
            return null;
        }

        private static TokenType getNfaIndex298(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(299);
            }
            return null;
        }

        private static TokenType getNfaIndex299(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(300);
            }
            return null;
        }

        private static TokenType getNfaIndex300(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(49);
            }
            return null;
        }

        private static TokenType getNfaIndex301(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                nextStates.set(302);
            }
            return null;
        }

        private static TokenType getNfaIndex302(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'b') {
                nextStates.set(303);
            }
            return null;
        }

        private static TokenType getNfaIndex303(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(50);
            }
            return null;
        }

        private static TokenType getNfaIndex304(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(305);
            }
            return null;
        }

        private static TokenType getNfaIndex305(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'k') {
                nextStates.set(306);
            }
            return null;
        }

        private static TokenType getNfaIndex306(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(307);
            }
            return null;
        }

        private static TokenType getNfaIndex307(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(308);
            }
            return null;
        }

        private static TokenType getNfaIndex308(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(309);
            }
            return null;
        }

        private static TokenType getNfaIndex309(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'z') {
                nextStates.set(51);
            }
            return null;
        }

        private static TokenType getNfaIndex310(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(311);
            }
            return null;
        }

        private static TokenType getNfaIndex311(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'x') {
                nextStates.set(312);
            }
            return null;
        }

        private static TokenType getNfaIndex312(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '-') {
                nextStates.set(313);
            }
            return null;
        }

        private static TokenType getNfaIndex313(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(314);
            }
            return null;
        }

        private static TokenType getNfaIndex314(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(315);
            }
            return null;
        }

        private static TokenType getNfaIndex315(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(316);
            }
            return null;
        }

        private static TokenType getNfaIndex316(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(317);
            }
            return null;
        }

        private static TokenType getNfaIndex317(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(318);
            }
            return null;
        }

        private static TokenType getNfaIndex318(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(319);
            }
            return null;
        }

        private static TokenType getNfaIndex319(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(320);
            }
            return null;
        }

        private static TokenType getNfaIndex320(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(321);
            }
            return null;
        }

        private static TokenType getNfaIndex321(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(322);
            }
            return null;
        }

        private static TokenType getNfaIndex322(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(52);
            }
            return null;
        }

        private static TokenType getNfaIndex323(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(324);
            }
            return null;
        }

        private static TokenType getNfaIndex324(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                nextStates.set(325);
            }
            return null;
        }

        private static TokenType getNfaIndex325(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'm') {
                nextStates.set(326);
            }
            return null;
        }

        private static TokenType getNfaIndex326(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(327);
            }
            return null;
        }

        private static TokenType getNfaIndex327(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(53);
            }
            return null;
        }

        private static TokenType getNfaIndex328(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(329);
            }
            return null;
        }

        private static TokenType getNfaIndex329(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(330);
            }
            return null;
        }

        private static TokenType getNfaIndex330(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(331);
            }
            return null;
        }

        private static TokenType getNfaIndex331(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'f') {
                nextStates.set(332);
            }
            return null;
        }

        private static TokenType getNfaIndex332(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(333);
            }
            return null;
        }

        private static TokenType getNfaIndex333(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(334);
            }
            return null;
        }

        private static TokenType getNfaIndex334(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(54);
            }
            return null;
        }

        private static TokenType getNfaIndex335(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(336);
            }
            return null;
        }

        private static TokenType getNfaIndex336(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(337);
            }
            return null;
        }

        private static TokenType getNfaIndex337(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(56);
            }
            return null;
        }

        private static TokenType getNfaIndex338(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(339);
            }
            return null;
        }

        private static TokenType getNfaIndex339(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(340);
            }
            return null;
        }

        private static TokenType getNfaIndex340(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'k') {
                nextStates.set(341);
            }
            return null;
        }

        private static TokenType getNfaIndex341(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(342);
            }
            return null;
        }

        private static TokenType getNfaIndex342(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'b') {
                nextStates.set(343);
            }
            return null;
        }

        private static TokenType getNfaIndex343(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(344);
            }
            return null;
        }

        private static TokenType getNfaIndex344(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(57);
            }
            return null;
        }

        private static TokenType getNfaIndex345(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '"') {
                nextStates.set(58);
            }
            return null;
        }

        private static TokenType getNfaIndex346(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(347);
            }
            return null;
        }

        private static TokenType getNfaIndex347(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(59);
            }
            return null;
        }

        private static TokenType getNfaIndex348(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(349);
            }
            return null;
        }

        private static TokenType getNfaIndex349(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(350);
            }
            return null;
        }

        private static TokenType getNfaIndex350(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(351);
            }
            return null;
        }

        private static TokenType getNfaIndex351(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(352);
            }
            return null;
        }

        private static TokenType getNfaIndex352(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'b') {
                nextStates.set(353);
            }
            return null;
        }

        private static TokenType getNfaIndex353(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(354);
            }
            return null;
        }

        private static TokenType getNfaIndex354(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(60);
            }
            return null;
        }

        private static TokenType getNfaIndex355(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(356);
            }
            return null;
        }

        private static TokenType getNfaIndex356(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(357);
            }
            return null;
        }

        private static TokenType getNfaIndex357(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'y') {
                nextStates.set(358);
            }
            return null;
        }

        private static TokenType getNfaIndex358(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(359);
            }
            return null;
        }

        private static TokenType getNfaIndex359(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'w') {
                nextStates.set(360);
            }
            return null;
        }

        private static TokenType getNfaIndex360(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(361);
            }
            return null;
        }

        private static TokenType getNfaIndex361(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(61);
            }
            return null;
        }

        private static TokenType getNfaIndex362(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(363);
            }
            return null;
        }

        private static TokenType getNfaIndex363(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(364);
            }
            return null;
        }

        private static TokenType getNfaIndex364(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(365);
            }
            return null;
        }

        private static TokenType getNfaIndex365(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(366);
            }
            return null;
        }

        private static TokenType getNfaIndex366(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(367);
            }
            return null;
        }

        private static TokenType getNfaIndex367(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(368);
            }
            return null;
        }

        private static TokenType getNfaIndex368(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                nextStates.set(369);
            }
            return null;
        }

        private static TokenType getNfaIndex369(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(370);
            }
            return null;
        }

        private static TokenType getNfaIndex370(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(371);
            }
            return null;
        }

        private static TokenType getNfaIndex371(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                nextStates.set(62);
            }
            return null;
        }

        private static TokenType getNfaIndex372(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(373);
            }
            return null;
        }

        private static TokenType getNfaIndex373(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'b') {
                nextStates.set(374);
            }
            return null;
        }

        private static TokenType getNfaIndex374(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(375);
            }
            return null;
        }

        private static TokenType getNfaIndex375(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(376);
            }
            return null;
        }

        private static TokenType getNfaIndex376(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(377);
            }
            return null;
        }

        private static TokenType getNfaIndex377(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(378);
            }
            return null;
        }

        private static TokenType getNfaIndex378(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(63);
            }
            return null;
        }

        private static TokenType getNfaIndex379(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(380);
            }
            return null;
        }

        private static TokenType getNfaIndex380(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(381);
            }
            return null;
        }

        private static TokenType getNfaIndex381(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(382);
            }
            return null;
        }

        private static TokenType getNfaIndex382(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(383);
            }
            return null;
        }

        private static TokenType getNfaIndex383(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(384);
            }
            return null;
        }

        private static TokenType getNfaIndex384(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'z') {
                nextStates.set(64);
            }
            return null;
        }

        private static TokenType getNfaIndex385(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(386);
            }
            return null;
        }

        private static TokenType getNfaIndex386(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(387);
            }
            return null;
        }

        private static TokenType getNfaIndex387(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(388);
            }
            return null;
        }

        private static TokenType getNfaIndex388(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'v') {
                nextStates.set(389);
            }
            return null;
        }

        private static TokenType getNfaIndex389(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(65);
            }
            return null;
        }

        private static TokenType getNfaIndex390(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(391);
            }
            return null;
        }

        private static TokenType getNfaIndex391(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'w') {
                nextStates.set(392);
            }
            return null;
        }

        private static TokenType getNfaIndex392(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(393);
            }
            return null;
        }

        private static TokenType getNfaIndex393(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(394);
            }
            return null;
        }

        private static TokenType getNfaIndex394(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(395);
            }
            return null;
        }

        private static TokenType getNfaIndex395(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(396);
            }
            return null;
        }

        private static TokenType getNfaIndex396(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(66);
            }
            return null;
        }

        private static TokenType getNfaIndex397(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(398);
            }
            return null;
        }

        private static TokenType getNfaIndex398(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(399);
            }
            return null;
        }

        private static TokenType getNfaIndex399(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(400);
            }
            return null;
        }

        private static TokenType getNfaIndex400(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(401);
            }
            return null;
        }

        private static TokenType getNfaIndex401(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'h') {
                nextStates.set(402);
            }
            return null;
        }

        private static TokenType getNfaIndex402(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(403);
            }
            return null;
        }

        private static TokenType getNfaIndex403(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(404);
            }
            return null;
        }

        private static TokenType getNfaIndex404(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(405);
            }
            return null;
        }

        private static TokenType getNfaIndex405(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                nextStates.set(67);
            }
            return null;
        }

        private static TokenType getNfaIndex406(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(407);
            }
            return null;
        }

        private static TokenType getNfaIndex407(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(68);
            }
            return null;
        }

        private static TokenType getNfaIndex408(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(409);
            }
            return null;
        }

        private static TokenType getNfaIndex409(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'x') {
                nextStates.set(410);
            }
            return null;
        }

        private static TokenType getNfaIndex410(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '-') {
                nextStates.set(411);
            }
            return null;
        }

        private static TokenType getNfaIndex411(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(412);
            }
            return null;
        }

        private static TokenType getNfaIndex412(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(413);
            }
            return null;
        }

        private static TokenType getNfaIndex413(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'k') {
                nextStates.set(414);
            }
            return null;
        }

        private static TokenType getNfaIndex414(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(415);
            }
            return null;
        }

        private static TokenType getNfaIndex415(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(416);
            }
            return null;
        }

        private static TokenType getNfaIndex416(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '-') {
                nextStates.set(417);
            }
            return null;
        }

        private static TokenType getNfaIndex417(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(418);
            }
            return null;
        }

        private static TokenType getNfaIndex418(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(419);
            }
            return null;
        }

        private static TokenType getNfaIndex419(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(420);
            }
            return null;
        }

        private static TokenType getNfaIndex420(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'g') {
                nextStates.set(421);
            }
            return null;
        }

        private static TokenType getNfaIndex421(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(69);
            }
            return null;
        }

        private static TokenType getNfaIndex422(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(423);
            }
            return null;
        }

        private static TokenType getNfaIndex423(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(424);
            }
            return null;
        }

        private static TokenType getNfaIndex424(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(425);
            }
            return null;
        }

        private static TokenType getNfaIndex425(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(426);
            }
            return null;
        }

        private static TokenType getNfaIndex426(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(427);
            }
            return null;
        }

        private static TokenType getNfaIndex427(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(70);
            }
            return null;
        }

        private static TokenType getNfaIndex428(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(429);
            }
            return null;
        }

        private static TokenType getNfaIndex429(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(430);
            }
            return null;
        }

        private static TokenType getNfaIndex430(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(431);
            }
            return null;
        }

        private static TokenType getNfaIndex431(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(432);
            }
            return null;
        }

        private static TokenType getNfaIndex432(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(433);
            }
            return null;
        }

        private static TokenType getNfaIndex433(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'b') {
                nextStates.set(434);
            }
            return null;
        }

        private static TokenType getNfaIndex434(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(71);
            }
            return null;
        }

        private static TokenType getNfaIndex435(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(436);
            }
            return null;
        }

        private static TokenType getNfaIndex436(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'x') {
                nextStates.set(437);
            }
            return null;
        }

        private static TokenType getNfaIndex437(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(438);
            }
            return null;
        }

        private static TokenType getNfaIndex438(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(439);
            }
            return null;
        }

        private static TokenType getNfaIndex439(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(440);
            }
            return null;
        }

        private static TokenType getNfaIndex440(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(441);
            }
            return null;
        }

        private static TokenType getNfaIndex441(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(72);
            }
            return null;
        }

        private static TokenType getNfaIndex442(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if ((ch == '+') || (ch == '-')) {
                nextStates.set(443);
            } else if (ch >= '0' && ch <= '9') {
                nextStates.set(74);
            }
            return null;
        }

        private static TokenType getNfaIndex443(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch >= '0' && ch <= '9') {
                nextStates.set(74);
            }
            return null;
        }

        private static TokenType getNfaIndex444(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(445);
            }
            return null;
        }

        private static TokenType getNfaIndex445(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(78);
            }
            return null;
        }

        private static TokenType getNfaIndex446(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(447);
            }
            return null;
        }

        private static TokenType getNfaIndex447(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(448);
            }
            return null;
        }

        private static TokenType getNfaIndex448(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'r') {
                nextStates.set(79);
            }
            return null;
        }

        private static TokenType getNfaIndex449(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(450);
            }
            return null;
        }

        private static TokenType getNfaIndex450(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'd') {
                nextStates.set(451);
            }
            return null;
        }

        private static TokenType getNfaIndex451(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(81);
            }
            return null;
        }

        private static TokenType getNfaIndex452(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(453);
            }
            return null;
        }

        private static TokenType getNfaIndex453(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(82);
            }
            return null;
        }

        private static TokenType getNfaIndex454(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(455);
            }
            return null;
        }

        private static TokenType getNfaIndex455(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(456);
            }
            return null;
        }

        private static TokenType getNfaIndex456(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'f') {
                nextStates.set(457);
            }
            return null;
        }

        private static TokenType getNfaIndex457(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(458);
            }
            return null;
        }

        private static TokenType getNfaIndex458(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                nextStates.set(459);
            }
            return null;
        }

        private static TokenType getNfaIndex459(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(83);
            }
            return null;
        }

        private static TokenType getNfaIndex460(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(461);
            }
            return null;
        }

        private static TokenType getNfaIndex461(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'l') {
                nextStates.set(462);
            }
            return null;
        }

        private static TokenType getNfaIndex462(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                nextStates.set(463);
            }
            return null;
        }

        private static TokenType getNfaIndex463(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'c') {
                nextStates.set(464);
            }
            return null;
        }

        private static TokenType getNfaIndex464(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(465);
            }
            return null;
        }

        private static TokenType getNfaIndex465(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == '_') {
                nextStates.set(466);
            }
            return null;
        }

        private static TokenType getNfaIndex466(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'i') {
                nextStates.set(467);
            }
            return null;
        }

        private static TokenType getNfaIndex467(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(468);
            }
            return null;
        }

        private static TokenType getNfaIndex468(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'p') {
                nextStates.set(469);
            }
            return null;
        }

        private static TokenType getNfaIndex469(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                nextStates.set(84);
            }
            return null;
        }

        private static void NFA_FUNCTIONS_init() {
            nfaFunctions = new NfaFunction[] {DEFAULT::getNfaIndex0, DEFAULT::getNfaIndex1,
            DEFAULT::getNfaIndex2, DEFAULT::getNfaIndex3, DEFAULT::getNfaIndex4, DEFAULT::getNfaIndex5,
            DEFAULT::getNfaIndex6, DEFAULT::getNfaIndex7, DEFAULT::getNfaIndex8, DEFAULT::getNfaIndex9,
            DEFAULT::getNfaIndex10, DEFAULT::getNfaIndex11, DEFAULT::getNfaIndex12,
            DEFAULT::getNfaIndex13, DEFAULT::getNfaIndex14, DEFAULT::getNfaIndex15,
            DEFAULT::getNfaIndex16, DEFAULT::getNfaIndex17, DEFAULT::getNfaIndex18,
            DEFAULT::getNfaIndex19, DEFAULT::getNfaIndex20, DEFAULT::getNfaIndex21,
            DEFAULT::getNfaIndex22, DEFAULT::getNfaIndex23, DEFAULT::getNfaIndex24,
            DEFAULT::getNfaIndex25, DEFAULT::getNfaIndex26, DEFAULT::getNfaIndex27,
            DEFAULT::getNfaIndex28, DEFAULT::getNfaIndex29, DEFAULT::getNfaIndex30,
            DEFAULT::getNfaIndex31, DEFAULT::getNfaIndex32, DEFAULT::getNfaIndex33,
            DEFAULT::getNfaIndex34, DEFAULT::getNfaIndex35, DEFAULT::getNfaIndex36,
            DEFAULT::getNfaIndex37, DEFAULT::getNfaIndex38, DEFAULT::getNfaIndex39,
            DEFAULT::getNfaIndex40, DEFAULT::getNfaIndex41, DEFAULT::getNfaIndex42,
            DEFAULT::getNfaIndex43, DEFAULT::getNfaIndex44, DEFAULT::getNfaIndex45,
            DEFAULT::getNfaIndex46, DEFAULT::getNfaIndex47, DEFAULT::getNfaIndex48,
            DEFAULT::getNfaIndex49, DEFAULT::getNfaIndex50, DEFAULT::getNfaIndex51,
            DEFAULT::getNfaIndex52, DEFAULT::getNfaIndex53, DEFAULT::getNfaIndex54,
            DEFAULT::getNfaIndex55, DEFAULT::getNfaIndex56, DEFAULT::getNfaIndex57,
            DEFAULT::getNfaIndex58, DEFAULT::getNfaIndex59, DEFAULT::getNfaIndex60,
            DEFAULT::getNfaIndex61, DEFAULT::getNfaIndex62, DEFAULT::getNfaIndex63,
            DEFAULT::getNfaIndex64, DEFAULT::getNfaIndex65, DEFAULT::getNfaIndex66,
            DEFAULT::getNfaIndex67, DEFAULT::getNfaIndex68, DEFAULT::getNfaIndex69,
            DEFAULT::getNfaIndex70, DEFAULT::getNfaIndex71, DEFAULT::getNfaIndex72,
            DEFAULT::getNfaIndex73, DEFAULT::getNfaIndex74, DEFAULT::getNfaIndex75,
            DEFAULT::getNfaIndex76, DEFAULT::getNfaIndex77, DEFAULT::getNfaIndex78,
            DEFAULT::getNfaIndex79, DEFAULT::getNfaIndex80, DEFAULT::getNfaIndex81,
            DEFAULT::getNfaIndex82, DEFAULT::getNfaIndex83, DEFAULT::getNfaIndex84,
            DEFAULT::getNfaIndex85, DEFAULT::getNfaIndex86, DEFAULT::getNfaIndex87,
            DEFAULT::getNfaIndex88, DEFAULT::getNfaIndex89, DEFAULT::getNfaIndex90,
            DEFAULT::getNfaIndex91, DEFAULT::getNfaIndex92, DEFAULT::getNfaIndex93,
            DEFAULT::getNfaIndex94, DEFAULT::getNfaIndex95, DEFAULT::getNfaIndex96,
            DEFAULT::getNfaIndex97, DEFAULT::getNfaIndex98, DEFAULT::getNfaIndex99,
            DEFAULT::getNfaIndex100, DEFAULT::getNfaIndex101, DEFAULT::getNfaIndex102,
            DEFAULT::getNfaIndex103, DEFAULT::getNfaIndex104, DEFAULT::getNfaIndex105,
            DEFAULT::getNfaIndex106, DEFAULT::getNfaIndex107, DEFAULT::getNfaIndex108,
            DEFAULT::getNfaIndex109, DEFAULT::getNfaIndex110, DEFAULT::getNfaIndex111,
            DEFAULT::getNfaIndex112, DEFAULT::getNfaIndex113, DEFAULT::getNfaIndex114,
            DEFAULT::getNfaIndex115, DEFAULT::getNfaIndex116, DEFAULT::getNfaIndex117,
            DEFAULT::getNfaIndex118, DEFAULT::getNfaIndex119, DEFAULT::getNfaIndex120,
            DEFAULT::getNfaIndex121, DEFAULT::getNfaIndex122, DEFAULT::getNfaIndex123,
            DEFAULT::getNfaIndex124, DEFAULT::getNfaIndex125, DEFAULT::getNfaIndex126,
            DEFAULT::getNfaIndex127, DEFAULT::getNfaIndex128, DEFAULT::getNfaIndex129,
            DEFAULT::getNfaIndex130, DEFAULT::getNfaIndex131, DEFAULT::getNfaIndex132,
            DEFAULT::getNfaIndex133, DEFAULT::getNfaIndex134, DEFAULT::getNfaIndex135,
            DEFAULT::getNfaIndex136, DEFAULT::getNfaIndex137, DEFAULT::getNfaIndex138,
            DEFAULT::getNfaIndex139, DEFAULT::getNfaIndex140, DEFAULT::getNfaIndex141,
            DEFAULT::getNfaIndex142, DEFAULT::getNfaIndex143, DEFAULT::getNfaIndex144,
            DEFAULT::getNfaIndex145, DEFAULT::getNfaIndex146, DEFAULT::getNfaIndex147,
            DEFAULT::getNfaIndex148, DEFAULT::getNfaIndex149, DEFAULT::getNfaIndex150,
            DEFAULT::getNfaIndex151, DEFAULT::getNfaIndex152, DEFAULT::getNfaIndex153,
            DEFAULT::getNfaIndex154, DEFAULT::getNfaIndex155, DEFAULT::getNfaIndex156,
            DEFAULT::getNfaIndex157, DEFAULT::getNfaIndex158, DEFAULT::getNfaIndex159,
            DEFAULT::getNfaIndex160, DEFAULT::getNfaIndex161, DEFAULT::getNfaIndex162,
            DEFAULT::getNfaIndex163, DEFAULT::getNfaIndex164, DEFAULT::getNfaIndex165,
            DEFAULT::getNfaIndex166, DEFAULT::getNfaIndex167, DEFAULT::getNfaIndex168,
            DEFAULT::getNfaIndex169, DEFAULT::getNfaIndex170, DEFAULT::getNfaIndex171,
            DEFAULT::getNfaIndex172, DEFAULT::getNfaIndex173, DEFAULT::getNfaIndex174,
            DEFAULT::getNfaIndex175, DEFAULT::getNfaIndex176, DEFAULT::getNfaIndex177,
            DEFAULT::getNfaIndex178, DEFAULT::getNfaIndex179, DEFAULT::getNfaIndex180,
            DEFAULT::getNfaIndex181, DEFAULT::getNfaIndex182, DEFAULT::getNfaIndex183,
            DEFAULT::getNfaIndex184, DEFAULT::getNfaIndex185, DEFAULT::getNfaIndex186,
            DEFAULT::getNfaIndex187, DEFAULT::getNfaIndex188, DEFAULT::getNfaIndex189,
            DEFAULT::getNfaIndex190, DEFAULT::getNfaIndex191, DEFAULT::getNfaIndex192,
            DEFAULT::getNfaIndex193, DEFAULT::getNfaIndex194, DEFAULT::getNfaIndex195,
            DEFAULT::getNfaIndex196, DEFAULT::getNfaIndex197, DEFAULT::getNfaIndex198,
            DEFAULT::getNfaIndex199, DEFAULT::getNfaIndex200, DEFAULT::getNfaIndex201,
            DEFAULT::getNfaIndex202, DEFAULT::getNfaIndex203, DEFAULT::getNfaIndex204,
            DEFAULT::getNfaIndex205, DEFAULT::getNfaIndex206, DEFAULT::getNfaIndex207,
            DEFAULT::getNfaIndex208, DEFAULT::getNfaIndex209, DEFAULT::getNfaIndex210,
            DEFAULT::getNfaIndex211, DEFAULT::getNfaIndex212, DEFAULT::getNfaIndex213,
            DEFAULT::getNfaIndex214, DEFAULT::getNfaIndex215, DEFAULT::getNfaIndex216,
            DEFAULT::getNfaIndex217, DEFAULT::getNfaIndex218, DEFAULT::getNfaIndex219,
            DEFAULT::getNfaIndex220, DEFAULT::getNfaIndex221, DEFAULT::getNfaIndex222,
            DEFAULT::getNfaIndex223, DEFAULT::getNfaIndex224, DEFAULT::getNfaIndex225,
            DEFAULT::getNfaIndex226, DEFAULT::getNfaIndex227, DEFAULT::getNfaIndex228,
            DEFAULT::getNfaIndex229, DEFAULT::getNfaIndex230, DEFAULT::getNfaIndex231,
            DEFAULT::getNfaIndex232, DEFAULT::getNfaIndex233, DEFAULT::getNfaIndex234,
            DEFAULT::getNfaIndex235, DEFAULT::getNfaIndex236, DEFAULT::getNfaIndex237,
            DEFAULT::getNfaIndex238, DEFAULT::getNfaIndex239, DEFAULT::getNfaIndex240,
            DEFAULT::getNfaIndex241, DEFAULT::getNfaIndex242, DEFAULT::getNfaIndex243,
            DEFAULT::getNfaIndex244, DEFAULT::getNfaIndex245, DEFAULT::getNfaIndex246,
            DEFAULT::getNfaIndex247, DEFAULT::getNfaIndex248, DEFAULT::getNfaIndex249,
            DEFAULT::getNfaIndex250, DEFAULT::getNfaIndex251, DEFAULT::getNfaIndex252,
            DEFAULT::getNfaIndex253, DEFAULT::getNfaIndex254, DEFAULT::getNfaIndex255,
            DEFAULT::getNfaIndex256, DEFAULT::getNfaIndex257, DEFAULT::getNfaIndex258,
            DEFAULT::getNfaIndex259, DEFAULT::getNfaIndex260, DEFAULT::getNfaIndex261,
            DEFAULT::getNfaIndex262, DEFAULT::getNfaIndex263, DEFAULT::getNfaIndex264,
            DEFAULT::getNfaIndex265, DEFAULT::getNfaIndex266, DEFAULT::getNfaIndex267,
            DEFAULT::getNfaIndex268, DEFAULT::getNfaIndex269, DEFAULT::getNfaIndex270,
            DEFAULT::getNfaIndex271, DEFAULT::getNfaIndex272, DEFAULT::getNfaIndex273,
            DEFAULT::getNfaIndex274, DEFAULT::getNfaIndex275, DEFAULT::getNfaIndex276,
            DEFAULT::getNfaIndex277, DEFAULT::getNfaIndex278, DEFAULT::getNfaIndex279,
            DEFAULT::getNfaIndex280, DEFAULT::getNfaIndex281, DEFAULT::getNfaIndex282,
            DEFAULT::getNfaIndex283, DEFAULT::getNfaIndex284, DEFAULT::getNfaIndex285,
            DEFAULT::getNfaIndex286, DEFAULT::getNfaIndex287, DEFAULT::getNfaIndex288,
            DEFAULT::getNfaIndex289, DEFAULT::getNfaIndex290, DEFAULT::getNfaIndex291,
            DEFAULT::getNfaIndex292, DEFAULT::getNfaIndex293, DEFAULT::getNfaIndex294,
            DEFAULT::getNfaIndex295, DEFAULT::getNfaIndex296, DEFAULT::getNfaIndex297,
            DEFAULT::getNfaIndex298, DEFAULT::getNfaIndex299, DEFAULT::getNfaIndex300,
            DEFAULT::getNfaIndex301, DEFAULT::getNfaIndex302, DEFAULT::getNfaIndex303,
            DEFAULT::getNfaIndex304, DEFAULT::getNfaIndex305, DEFAULT::getNfaIndex306,
            DEFAULT::getNfaIndex307, DEFAULT::getNfaIndex308, DEFAULT::getNfaIndex309,
            DEFAULT::getNfaIndex310, DEFAULT::getNfaIndex311, DEFAULT::getNfaIndex312,
            DEFAULT::getNfaIndex313, DEFAULT::getNfaIndex314, DEFAULT::getNfaIndex315,
            DEFAULT::getNfaIndex316, DEFAULT::getNfaIndex317, DEFAULT::getNfaIndex318,
            DEFAULT::getNfaIndex319, DEFAULT::getNfaIndex320, DEFAULT::getNfaIndex321,
            DEFAULT::getNfaIndex322, DEFAULT::getNfaIndex323, DEFAULT::getNfaIndex324,
            DEFAULT::getNfaIndex325, DEFAULT::getNfaIndex326, DEFAULT::getNfaIndex327,
            DEFAULT::getNfaIndex328, DEFAULT::getNfaIndex329, DEFAULT::getNfaIndex330,
            DEFAULT::getNfaIndex331, DEFAULT::getNfaIndex332, DEFAULT::getNfaIndex333,
            DEFAULT::getNfaIndex334, DEFAULT::getNfaIndex335, DEFAULT::getNfaIndex336,
            DEFAULT::getNfaIndex337, DEFAULT::getNfaIndex338, DEFAULT::getNfaIndex339,
            DEFAULT::getNfaIndex340, DEFAULT::getNfaIndex341, DEFAULT::getNfaIndex342,
            DEFAULT::getNfaIndex343, DEFAULT::getNfaIndex344, DEFAULT::getNfaIndex345,
            DEFAULT::getNfaIndex346, DEFAULT::getNfaIndex347, DEFAULT::getNfaIndex348,
            DEFAULT::getNfaIndex349, DEFAULT::getNfaIndex350, DEFAULT::getNfaIndex351,
            DEFAULT::getNfaIndex352, DEFAULT::getNfaIndex353, DEFAULT::getNfaIndex354,
            DEFAULT::getNfaIndex355, DEFAULT::getNfaIndex356, DEFAULT::getNfaIndex357,
            DEFAULT::getNfaIndex358, DEFAULT::getNfaIndex359, DEFAULT::getNfaIndex360,
            DEFAULT::getNfaIndex361, DEFAULT::getNfaIndex362, DEFAULT::getNfaIndex363,
            DEFAULT::getNfaIndex364, DEFAULT::getNfaIndex365, DEFAULT::getNfaIndex366,
            DEFAULT::getNfaIndex367, DEFAULT::getNfaIndex368, DEFAULT::getNfaIndex369,
            DEFAULT::getNfaIndex370, DEFAULT::getNfaIndex371, DEFAULT::getNfaIndex372,
            DEFAULT::getNfaIndex373, DEFAULT::getNfaIndex374, DEFAULT::getNfaIndex375,
            DEFAULT::getNfaIndex376, DEFAULT::getNfaIndex377, DEFAULT::getNfaIndex378,
            DEFAULT::getNfaIndex379, DEFAULT::getNfaIndex380, DEFAULT::getNfaIndex381,
            DEFAULT::getNfaIndex382, DEFAULT::getNfaIndex383, DEFAULT::getNfaIndex384,
            DEFAULT::getNfaIndex385, DEFAULT::getNfaIndex386, DEFAULT::getNfaIndex387,
            DEFAULT::getNfaIndex388, DEFAULT::getNfaIndex389, DEFAULT::getNfaIndex390,
            DEFAULT::getNfaIndex391, DEFAULT::getNfaIndex392, DEFAULT::getNfaIndex393,
            DEFAULT::getNfaIndex394, DEFAULT::getNfaIndex395, DEFAULT::getNfaIndex396,
            DEFAULT::getNfaIndex397, DEFAULT::getNfaIndex398, DEFAULT::getNfaIndex399,
            DEFAULT::getNfaIndex400, DEFAULT::getNfaIndex401, DEFAULT::getNfaIndex402,
            DEFAULT::getNfaIndex403, DEFAULT::getNfaIndex404, DEFAULT::getNfaIndex405,
            DEFAULT::getNfaIndex406, DEFAULT::getNfaIndex407, DEFAULT::getNfaIndex408,
            DEFAULT::getNfaIndex409, DEFAULT::getNfaIndex410, DEFAULT::getNfaIndex411,
            DEFAULT::getNfaIndex412, DEFAULT::getNfaIndex413, DEFAULT::getNfaIndex414,
            DEFAULT::getNfaIndex415, DEFAULT::getNfaIndex416, DEFAULT::getNfaIndex417,
            DEFAULT::getNfaIndex418, DEFAULT::getNfaIndex419, DEFAULT::getNfaIndex420,
            DEFAULT::getNfaIndex421, DEFAULT::getNfaIndex422, DEFAULT::getNfaIndex423,
            DEFAULT::getNfaIndex424, DEFAULT::getNfaIndex425, DEFAULT::getNfaIndex426,
            DEFAULT::getNfaIndex427, DEFAULT::getNfaIndex428, DEFAULT::getNfaIndex429,
            DEFAULT::getNfaIndex430, DEFAULT::getNfaIndex431, DEFAULT::getNfaIndex432,
            DEFAULT::getNfaIndex433, DEFAULT::getNfaIndex434, DEFAULT::getNfaIndex435,
            DEFAULT::getNfaIndex436, DEFAULT::getNfaIndex437, DEFAULT::getNfaIndex438,
            DEFAULT::getNfaIndex439, DEFAULT::getNfaIndex440, DEFAULT::getNfaIndex441,
            DEFAULT::getNfaIndex442, DEFAULT::getNfaIndex443, DEFAULT::getNfaIndex444,
            DEFAULT::getNfaIndex445, DEFAULT::getNfaIndex446, DEFAULT::getNfaIndex447,
            DEFAULT::getNfaIndex448, DEFAULT::getNfaIndex449, DEFAULT::getNfaIndex450,
            DEFAULT::getNfaIndex451, DEFAULT::getNfaIndex452, DEFAULT::getNfaIndex453,
            DEFAULT::getNfaIndex454, DEFAULT::getNfaIndex455, DEFAULT::getNfaIndex456,
            DEFAULT::getNfaIndex457, DEFAULT::getNfaIndex458, DEFAULT::getNfaIndex459,
            DEFAULT::getNfaIndex460, DEFAULT::getNfaIndex461, DEFAULT::getNfaIndex462,
            DEFAULT::getNfaIndex463, DEFAULT::getNfaIndex464, DEFAULT::getNfaIndex465,
            DEFAULT::getNfaIndex466, DEFAULT::getNfaIndex467, DEFAULT::getNfaIndex468,
            DEFAULT::getNfaIndex469};
        }

    }

}