• Home
• com.yahoo.vespa
• schema-language-server
• 8.439.22
• source code
• GroupingParserLexer.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.grouping.GroupingParserLexer Maven / Gradle / Ivy

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

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


public class GroupingParserLexer extends TokenSource {
    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, SCOLON, COMMA, DOLLAR, DOT, EQ, INFIX_ADD, INFIX_DIV, INFIX_MOD, INFIX_MUL, INFIX_SUB, LBRACE, RBRACE, LCURLY, RCURLY, LT, GT, LBRACKET, RBRACKET, INF, NEGINF, ACOS, ACOSH, ACCURACY, ADD, ALIAS, ALL, AND, ARRAY, AS, AT, ASIN, ASINH, ATAN, ATANH, ATTRIBUTE, AVG, BUCKET, CAT, CBRT, COS, COSH, COUNT, DEBUGWAIT, DIV, DOCIDNSSPECIFIC, EACH, EXP, FIXEDWIDTH, FLOOR, GROUP, HINT, HYPOT, LOG, LOG1P, LOG10, MATH, MAX, MD5, MIN, MOD, MUL, NEG, NORMALIZESUBJECT, NOW, OR, ORDER, OUTPUT, POW, PRECISION, PREDEFINED, RELEVANCE, REVERSE, SIN, SINH, SIZE, SORT, INTERPOLATEDLOOKUP, SQRT, STDDEV, STRCAT, STRLEN, SUB, SUM, SUMMARY, TAN, TANH, TIME, TIME_DATE, TIME_DAYOFMONTH, TIME_DAYOFWEEK, TIME_DAYOFYEAR, TIME_HOUROFDAY, TIME_MINUTEOFHOUR, TIME_MONTHOFYEAR, TIME_SECONDOFMINUTE, TIME_YEAR, TODOUBLE, TOLONG, TORAW, TOSTRING, TRUE, FALSE, UCA, WHERE, X, XOR, XORBIT, Y, ZCURVE, INTEGER, FLOAT, SPACE, STRING, IDENTIFIER);
    // Token types that do not participate in parsing
    // i.e. declared as UNPARSED (or SPECIAL_TOKEN)
    static final EnumSet unparsedTokens = EnumSet.noneOf(TokenType.class);
    // Tokens that are skipped, i.e. SKIP
    static final EnumSet skippedTokens = EnumSet.noneOf(TokenType.class);
    // Tokens that correspond to a MORE, i.e. that are pending
    // additional input
    static final EnumSet moreTokens = EnumSet.noneOf(TokenType.class);

    public GroupingParserLexer(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 GroupingParserLexer(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 GroupingParserLexer(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 GroupingParser.
    * 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 GroupingParserLexer
        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(540);
        else currentStates.clear();
        if (nextStates == null) nextStates = new BitSet(540);
        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(540);
        BitSet nextStates = new BitSet(540);
        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(STRING)) {
                    nextStates.set(1);
                }
            } else if (ch == '\'') {
                if (validTypes == null || validTypes.contains(STRING)) {
                    nextStates.set(15);
                }
            } else if (ch == '-') {
                if (validTypes == null || validTypes.contains(NEGINF)) {
                    nextStates.set(129);
                }
            } else if (ch == '0') {
                if (validTypes == null || validTypes.contains(INTEGER)) {
                    nextStates.set(216);
                }
            } else if (ch == 'a') {
                if (validTypes == null || validTypes.contains(ALL)) {
                    nextStates.set(131);
                }
                if (validTypes == null || validTypes.contains(AS)) {
                    nextStates.set(10);
                }
                if (validTypes == null || validTypes.contains(ATANH)) {
                    nextStates.set(159);
                }
                if (validTypes == null || validTypes.contains(AT)) {
                    nextStates.set(23);
                }
                if (validTypes == null || validTypes.contains(ACOS)) {
                    nextStates.set(210);
                }
                if (validTypes == null || validTypes.contains(ATAN)) {
                    nextStates.set(213);
                }
                if (validTypes == null || validTypes.contains(AVG)) {
                    nextStates.set(215);
                }
                if (validTypes == null || validTypes.contains(ARRAY)) {
                    nextStates.set(231);
                }
                if (validTypes == null || validTypes.contains(AND)) {
                    nextStates.set(271);
                }
                if (validTypes == null || validTypes.contains(ATTRIBUTE)) {
                    nextStates.set(274);
                }
                if (validTypes == null || validTypes.contains(ADD)) {
                    nextStates.set(288);
                }
                if (validTypes == null || validTypes.contains(ASIN)) {
                    nextStates.set(299);
                }
                if (validTypes == null || validTypes.contains(ASINH)) {
                    nextStates.set(337);
                }
                if (validTypes == null || validTypes.contains(ACOSH)) {
                    nextStates.set(353);
                }
                if (validTypes == null || validTypes.contains(ALIAS)) {
                    nextStates.set(397);
                }
                if (validTypes == null || validTypes.contains(ACCURACY)) {
                    nextStates.set(408);
                }
            } else if (ch == 'b') {
                if (validTypes == null || validTypes.contains(BUCKET)) {
                    nextStates.set(292);
                }
            } else if (ch == 'c') {
                if (validTypes == null || validTypes.contains(COS)) {
                    nextStates.set(212);
                }
                if (validTypes == null || validTypes.contains(COUNT)) {
                    nextStates.set(305);
                }
                if (validTypes == null || validTypes.contains(COSH)) {
                    nextStates.set(328);
                }
                if (validTypes == null || validTypes.contains(CAT)) {
                    nextStates.set(344);
                }
                if (validTypes == null || validTypes.contains(CBRT)) {
                    nextStates.set(364);
                }
            } else if (ch == 'd') {
                if (validTypes == null || validTypes.contains(DEBUGWAIT)) {
                    nextStates.set(103);
                }
                if (validTypes == null || validTypes.contains(TIME_DAYOFWEEK)) {
                    nextStates.set(146);
                }
                if (validTypes == null || validTypes.contains(DOCIDNSSPECIFIC)) {
                    nextStates.set(238);
                }
                if (validTypes == null || validTypes.contains(DIV)) {
                    nextStates.set(287);
                }
                if (validTypes == null || validTypes.contains(TIME_DAYOFYEAR)) {
                    nextStates.set(320);
                }
                if (validTypes == null || validTypes.contains(TIME_DAYOFMONTH)) {
                    nextStates.set(374);
                }
                if (validTypes == null || validTypes.contains(TIME_DATE)) {
                    nextStates.set(415);
                }
            } else if (ch == 'e') {
                if (validTypes == null || validTypes.contains(EXP)) {
                    nextStates.set(180);
                }
                if (validTypes == null || validTypes.contains(EACH)) {
                    nextStates.set(400);
                }
            } else if (ch == 'f') {
                if (validTypes == null || validTypes.contains(FLOOR)) {
                    nextStates.set(289);
                }
                if (validTypes == null || validTypes.contains(FIXEDWIDTH)) {
                    nextStates.set(385);
                }
                if (validTypes == null || validTypes.contains(FALSE)) {
                    nextStates.set(405);
                }
            } else if (ch == 'g') {
                if (validTypes == null || validTypes.contains(GROUP)) {
                    nextStates.set(317);
                }
            } else if (ch == 'h') {
                if (validTypes == null || validTypes.contains(TIME_HOUROFDAY)) {
                    nextStates.set(262);
                }
                if (validTypes == null || validTypes.contains(HYPOT)) {
                    nextStates.set(284);
                }
                if (validTypes == null || validTypes.contains(HINT)) {
                    nextStates.set(394);
                }
            } else if (ch == 'i') {
                if (validTypes == null || validTypes.contains(INTERPOLATEDLOOKUP)) {
                    nextStates.set(113);
                }
                if (validTypes == null || validTypes.contains(INF)) {
                    nextStates.set(366);
                }
            } else if (ch == 'l') {
                if (validTypes == null || validTypes.contains(LOG10)) {
                    nextStates.set(191);
                }
                if (validTypes == null || validTypes.contains(LOG)) {
                    nextStates.set(301);
                }
                if (validTypes == null || validTypes.contains(LOG1P)) {
                    nextStates.set(330);
                }
            } else if (ch == 'm') {
                if (validTypes == null || validTypes.contains(MUL)) {
                    nextStates.set(132);
                }
                if (validTypes == null || validTypes.contains(TIME_MINUTEOFHOUR)) {
                    nextStates.set(181);
                }
                if (validTypes == null || validTypes.contains(TIME_MONTHOFYEAR)) {
                    nextStates.set(201);
                }
                if (validTypes == null || validTypes.contains(MIN)) {
                    nextStates.set(229);
                }
                if (validTypes == null || validTypes.contains(MD5)) {
                    nextStates.set(230);
                }
                if (validTypes == null || validTypes.contains(MAX)) {
                    nextStates.set(298);
                }
                if (validTypes == null || validTypes.contains(MATH)) {
                    nextStates.set(310);
                }
                if (validTypes == null || validTypes.contains(MOD)) {
                    nextStates.set(384);
                }
            } else if (ch == 'n') {
                if (validTypes == null || validTypes.contains(NORMALIZESUBJECT)) {
                    nextStates.set(166);
                }
                if (validTypes == null || validTypes.contains(NEG)) {
                    nextStates.set(343);
                }
                if (validTypes == null || validTypes.contains(NOW)) {
                    nextStates.set(402);
                }
            } else if (ch == 'o') {
                if (validTypes == null || validTypes.contains(OUTPUT)) {
                    nextStates.set(258);
                }
                if (validTypes == null || validTypes.contains(ORDER)) {
                    nextStates.set(302);
                }
                if (validTypes == null || validTypes.contains(OR)) {
                    nextStates.set(67);
                }
            } else if (ch == 'p') {
                if (validTypes == null || validTypes.contains(POW)) {
                    nextStates.set(112);
                }
                if (validTypes == null || validTypes.contains(PREDEFINED)) {
                    nextStates.set(356);
                }
                if (validTypes == null || validTypes.contains(PRECISION)) {
                    nextStates.set(367);
                }
            } else if (ch == 'r') {
                if (validTypes == null || validTypes.contains(RELEVANCE)) {
                    nextStates.set(194);
                }
                if (validTypes == null || validTypes.contains(REVERSE)) {
                    nextStates.set(312);
                }
            } else if (ch == 's') {
                if (validTypes == null || validTypes.contains(SUMMARY)) {
                    nextStates.set(133);
                }
                if (validTypes == null || validTypes.contains(STRLEN)) {
                    nextStates.set(138);
                }
                if (validTypes == null || validTypes.contains(STRCAT)) {
                    nextStates.set(142);
                }
                if (validTypes == null || validTypes.contains(TIME_SECONDOFMINUTE)) {
                    nextStates.set(217);
                }
                if (validTypes == null || validTypes.contains(STDDEV)) {
                    nextStates.set(234);
                }
                if (validTypes == null || validTypes.contains(SORT)) {
                    nextStates.set(296);
                }
                if (validTypes == null || validTypes.contains(SINH)) {
                    nextStates.set(308);
                }
                if (validTypes == null || validTypes.contains(SUM)) {
                    nextStates.set(327);
                }
                if (validTypes == null || validTypes.contains(SQRT)) {
                    nextStates.set(351);
                }
                if (validTypes == null || validTypes.contains(SIZE)) {
                    nextStates.set(382);
                }
                if (validTypes == null || validTypes.contains(SIN)) {
                    nextStates.set(396);
                }
                if (validTypes == null || validTypes.contains(SUB)) {
                    nextStates.set(414);
                }
            } else if (ch == 't') {
                if (validTypes == null || validTypes.contains(TOLONG)) {
                    nextStates.set(162);
                }
                if (validTypes == null || validTypes.contains(TODOUBLE)) {
                    nextStates.set(251);
                }
                if (validTypes == null || validTypes.contains(TRUE)) {
                    nextStates.set(269);
                }
                if (validTypes == null || validTypes.contains(TIME)) {
                    nextStates.set(272);
                }
                if (validTypes == null || validTypes.contains(TORAW)) {
                    nextStates.set(340);
                }
                if (validTypes == null || validTypes.contains(TOSTRING)) {
                    nextStates.set(345);
                }
                if (validTypes == null || validTypes.contains(TAN)) {
                    nextStates.set(393);
                }
                if (validTypes == null || validTypes.contains(TANH)) {
                    nextStates.set(403);
                }
            } else if (ch == 'u') {
                if (validTypes == null || validTypes.contains(UCA)) {
                    nextStates.set(153);
                }
            } else if (ch == 'w') {
                if (validTypes == null || validTypes.contains(WHERE)) {
                    nextStates.set(281);
                }
            } else if (ch == 'x') {
                if (validTypes == null || validTypes.contains(XORBIT)) {
                    nextStates.set(155);
                }
                if (validTypes == null || validTypes.contains(XOR)) {
                    nextStates.set(257);
                }
            } else if (ch == 'y') {
                if (validTypes == null || validTypes.contains(TIME_YEAR)) {
                    nextStates.set(110);
                }
            } else if (ch == 'z') {
                if (validTypes == null || validTypes.contains(ZCURVE)) {
                    nextStates.set(333);
                }
            }
            if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
                if (validTypes == null || validTypes.contains(IDENTIFIER)) {
                    nextStates.set(38);
                    type = IDENTIFIER;
                }
            } else if ((ch == '\t' || ch == '\n') || ((ch == '\r') || (ch == ' '))) {
                if (validTypes == null || validTypes.contains(SPACE)) {
                    type = SPACE;
                }
            } else if (ch >= '0' && ch <= '9') {
                if (validTypes == null || validTypes.contains(FLOAT)) {
                    nextStates.set(51);
                    type = FLOAT;
                }
            }
            if (ch == '0') {
                if (validTypes == null || validTypes.contains(INTEGER)) {
                    nextStates.set(22);
                    type = INTEGER;
                }
            } else if (ch >= '1' && ch <= '9') {
                if (validTypes == null || validTypes.contains(INTEGER)) {
                    nextStates.set(77);
                    type = INTEGER;
                }
            } else if (ch == 'y') {
                if (validTypes == null || validTypes.contains(Y)) {
                    type = Y;
                }
            } else if (ch == 'x') {
                if (validTypes == null || validTypes.contains(X)) {
                    type = X;
                }
            } else if (ch == ']') {
                if (validTypes == null || validTypes.contains(RBRACKET)) {
                    type = RBRACKET;
                }
            } else if (ch == '[') {
                if (validTypes == null || validTypes.contains(LBRACKET)) {
                    type = LBRACKET;
                }
            } 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(RCURLY)) {
                    type = RCURLY;
                }
            } else if (ch == '{') {
                if (validTypes == null || validTypes.contains(LCURLY)) {
                    type = LCURLY;
                }
            } else if (ch == ')') {
                if (validTypes == null || validTypes.contains(RBRACE)) {
                    type = RBRACE;
                }
            } else if (ch == '(') {
                if (validTypes == null || validTypes.contains(LBRACE)) {
                    type = LBRACE;
                }
            } else if (ch == '-') {
                if (validTypes == null || validTypes.contains(INFIX_SUB)) {
                    type = INFIX_SUB;
                }
            } else if (ch == '*') {
                if (validTypes == null || validTypes.contains(INFIX_MUL)) {
                    type = INFIX_MUL;
                }
            } else if (ch == '%') {
                if (validTypes == null || validTypes.contains(INFIX_MOD)) {
                    type = INFIX_MOD;
                }
            } else if (ch == '/') {
                if (validTypes == null || validTypes.contains(INFIX_DIV)) {
                    type = INFIX_DIV;
                }
            } else if (ch == '+') {
                if (validTypes == null || validTypes.contains(INFIX_ADD)) {
                    type = INFIX_ADD;
                }
            } else if (ch == '=') {
                if (validTypes == null || validTypes.contains(EQ)) {
                    type = EQ;
                }
            } else if (ch == '.') {
                if (validTypes == null || validTypes.contains(DOT)) {
                    type = DOT;
                }
            } else if (ch == '$') {
                if (validTypes == null || validTypes.contains(DOLLAR)) {
                    type = DOLLAR;
                }
            } else if (ch == ',') {
                if (validTypes == null || validTypes.contains(COMMA)) {
                    type = COMMA;
                }
            } else if (ch == ';') {
                if (validTypes == null || validTypes.contains(SCOLON)) {
                    type = SCOLON;
                }
            }
            return type;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static TokenType getNfaIndex32(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(32);
                type = INTEGER;
            } else if ((ch == 'L') || (ch == 'l')) {
                type = INTEGER;
            }
            return type;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static TokenType getNfaIndex118(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                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 == 'a') {
                nextStates.set(121);
            }
            return null;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static TokenType getNfaIndex165(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(18);
            }
            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 == 'r') {
                nextStates.set(168);
            }
            return null;
        }

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

        private static TokenType getNfaIndex169(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(170);
            }
            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 == 'i') {
                nextStates.set(172);
            }
            return null;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static TokenType getNfaIndex209(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'a') {
                nextStates.set(26);
            }
            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(27);
            }
            return null;
        }

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

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

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

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

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

        private static TokenType getNfaIndex217(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'e') {
                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 == 'o') {
                nextStates.set(220);
            }
            return null;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static TokenType getNfaIndex307(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'n') {
                nextStates.set(64);
            }
            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 == 'n') {
                nextStates.set(65);
            }
            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 == 't') {
                nextStates.set(66);
            }
            return null;
        }

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

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

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

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

        private static TokenType getNfaIndex316(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 's') {
                nextStates.set(68);
            }
            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 == 'o') {
                nextStates.set(319);
            }
            return null;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static TokenType getNfaIndex379(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'o') {
                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 == 't') {
                nextStates.set(87);
            }
            return null;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static TokenType getNfaIndex416(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 't') {
                nextStates.set(101);
            }
            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};
        }

    }

}