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

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

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


public class RankingExpressionParserLexer extends TokenSource {

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

    private static MatcherHook MATCHER_HOOK;

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

    LexicalState lexicalState = LexicalState.values()[0];
    EnumSet activeTokenTypes = null;
    // Token types that are "regular" tokens that participate in parsing,
    // i.e. declared as TOKEN
    static final EnumSet regularTokens = EnumSet.of(EOF, LBRACE, RBRACE, LSQUARE, RSQUARE, LCURLY, RCURLY, ADD, SUB, DIV, MUL, DOT, MOD, POWOP, DOLLAR, COMMA, COLON, GREATEREQUAL, GREATER, LESSEQUAL, LESS, APPROX, NOTEQUAL, EQUAL, IF, IN, F, NOT, AND, OR, ABS, ACOS, ASIN, ATAN, CEIL, COS, COSH, ELU, EXP, FABS, FLOOR, ISNAN, LOG, LOG10, RELU, ROUND, SIGMOID, SIGN, SIN, SINH, SQUARE, SQRT, TAN, TANH, ERF, ATAN2, FMOD, LDEXP, POW, BIT, HAMMING, MAP, MAP_SUBSPACES, UNPACK_BITS, REDUCE, JOIN, MERGE, RENAME, CONCAT, TENSOR, RANGE, DIAG, RANDOM, L1_NORMALIZE, L2_NORMALIZE, EUCLIDEAN_DISTANCE, COSINE_SIMILARITY, MATMUL, SOFTMAX, XW_PLUS_B, ARGMAX, ARGMIN, CELL_CAST, EXPAND, AVG, COUNT, MAX, MEDIAN, MIN, PROD, SUM, TRUE, FALSE, INTEGER, FLOAT, STRING, IDENTIFIER);
    // Token types that do not participate in parsing
    // i.e. declared as UNPARSED (or SPECIAL_TOKEN)
    static final EnumSet unparsedTokens = EnumSet.of(SINGLE_LINE_COMMENT);
    // Tokens that are skipped, i.e. SKIP
    static final EnumSet skippedTokens = EnumSet.of(_TOKEN_93);
    // Tokens that correspond to a MORE, i.e. that are pending
    // additional input
    static final EnumSet moreTokens = EnumSet.noneOf(TokenType.class);

    public RankingExpressionParserLexer(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 RankingExpressionParserLexer(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 RankingExpressionParserLexer(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 RankingExpressionParser.
    * 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 RankingExpressionParserLexer
        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(417);
        else currentStates.clear();
        if (nextStates == null) nextStates = new BitSet(417);
        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(417);
        BitSet nextStates = new BitSet(417);
        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(NOTEQUAL)) {
                    nextStates.set(39);
                }
            } else if (ch == '"') {
                if (validTypes == null || validTypes.contains(STRING)) {
                    nextStates.set(78);
                }
            } else if (ch == '&') {
                if (validTypes == null || validTypes.contains(AND)) {
                    nextStates.set(1);
                }
            } else if (ch == '\'') {
                if (validTypes == null || validTypes.contains(STRING)) {
                    nextStates.set(58);
                }
            } else if (ch == '0') {
                if (validTypes == null || validTypes.contains(INTEGER)) {
                    nextStates.set(276);
                }
            } else if (ch == '<') {
                if (validTypes == null || validTypes.contains(LESSEQUAL)) {
                    nextStates.set(43);
                }
            } else if (ch == '=') {
                if (validTypes == null || validTypes.contains(EQUAL)) {
                    nextStates.set(40);
                }
            } else if (ch == '>') {
                if (validTypes == null || validTypes.contains(GREATEREQUAL)) {
                    nextStates.set(67);
                }
            } else if (ch == 'a') {
                if (validTypes == null || validTypes.contains(ABS)) {
                    nextStates.set(91);
                }
                if (validTypes == null || validTypes.contains(ARGMAX)) {
                    nextStates.set(116);
                }
                if (validTypes == null || validTypes.contains(AVG)) {
                    nextStates.set(140);
                }
                if (validTypes == null || validTypes.contains(ATAN)) {
                    nextStates.set(150);
                }
                if (validTypes == null || validTypes.contains(ATAN2)) {
                    nextStates.set(185);
                }
                if (validTypes == null || validTypes.contains(ACOS)) {
                    nextStates.set(201);
                }
                if (validTypes == null || validTypes.contains(ASIN)) {
                    nextStates.set(221);
                }
                if (validTypes == null || validTypes.contains(ARGMIN)) {
                    nextStates.set(225);
                }
            } else if (ch == 'b') {
                if (validTypes == null || validTypes.contains(BIT)) {
                    nextStates.set(282);
                }
            } else if (ch == 'c') {
                if (validTypes == null || validTypes.contains(CELL_CAST)) {
                    nextStates.set(133);
                }
                if (validTypes == null || validTypes.contains(COS)) {
                    nextStates.set(153);
                }
                if (validTypes == null || validTypes.contains(CEIL)) {
                    nextStates.set(157);
                }
                if (validTypes == null || validTypes.contains(COSH)) {
                    nextStates.set(163);
                }
                if (validTypes == null || validTypes.contains(CONCAT)) {
                    nextStates.set(167);
                }
                if (validTypes == null || validTypes.contains(COUNT)) {
                    nextStates.set(171);
                }
                if (validTypes == null || validTypes.contains(COSINE_SIMILARITY)) {
                    nextStates.set(258);
                }
            } else if (ch == 'd') {
                if (validTypes == null || validTypes.contains(DIAG)) {
                    nextStates.set(256);
                }
            } else if (ch == 'e') {
                if (validTypes == null || validTypes.contains(ERF)) {
                    nextStates.set(110);
                }
                if (validTypes == null || validTypes.contains(EXP)) {
                    nextStates.set(156);
                }
                if (validTypes == null || validTypes.contains(EXPAND)) {
                    nextStates.set(159);
                }
                if (validTypes == null || validTypes.contains(ELU)) {
                    nextStates.set(196);
                }
                if (validTypes == null || validTypes.contains(EUCLIDEAN_DISTANCE)) {
                    nextStates.set(238);
                }
            } else if (ch == 'f') {
                if (validTypes == null || validTypes.contains(FMOD)) {
                    nextStates.set(86);
                }
                if (validTypes == null || validTypes.contains(FABS)) {
                    nextStates.set(120);
                }
                if (validTypes == null || validTypes.contains(FALSE)) {
                    nextStates.set(288);
                }
                if (validTypes == null || validTypes.contains(FLOOR)) {
                    nextStates.set(292);
                }
            } else if (ch == 'h') {
                if (validTypes == null || validTypes.contains(HAMMING)) {
                    nextStates.set(105);
                }
            } else if (ch == 'i') {
                if (validTypes == null || validTypes.contains(ISNAN)) {
                    nextStates.set(88);
                }
                if (validTypes == null || validTypes.contains(IF)) {
                    nextStates.set(23);
                }
                if (validTypes == null || validTypes.contains(IN)) {
                    nextStates.set(31);
                }
            } else if (ch == 'j') {
                if (validTypes == null || validTypes.contains(JOIN)) {
                    nextStates.set(199);
                }
            } else if (ch == 'l') {
                if (validTypes == null || validTypes.contains(LOG10)) {
                    nextStates.set(122);
                }
                if (validTypes == null || validTypes.contains(LDEXP)) {
                    nextStates.set(174);
                }
                if (validTypes == null || validTypes.contains(LOG)) {
                    nextStates.set(197);
                }
                if (validTypes == null || validTypes.contains(L1_NORMALIZE)) {
                    nextStates.set(210);
                }
                if (validTypes == null || validTypes.contains(L2_NORMALIZE)) {
                    nextStates.set(300);
                }
            } else if (ch == 'm') {
                if (validTypes == null || validTypes.contains(MAP_SUBSPACES)) {
                    nextStates.set(94);
                }
                if (validTypes == null || validTypes.contains(MATMUL)) {
                    nextStates.set(146);
                }
                if (validTypes == null || validTypes.contains(MIN)) {
                    nextStates.set(220);
                }
                if (validTypes == null || validTypes.contains(MERGE)) {
                    nextStates.set(279);
                }
                if (validTypes == null || validTypes.contains(MEDIAN)) {
                    nextStates.set(283);
                }
                if (validTypes == null || validTypes.contains(MAX)) {
                    nextStates.set(291);
                }
                if (validTypes == null || validTypes.contains(MAP)) {
                    nextStates.set(295);
                }
            } else if (ch == 'p') {
                if (validTypes == null || validTypes.contains(PROD)) {
                    nextStates.set(165);
                }
                if (validTypes == null || validTypes.contains(POW)) {
                    nextStates.set(198);
                }
            } else if (ch == 'r') {
                if (validTypes == null || validTypes.contains(RENAME)) {
                    nextStates.set(181);
                }
                if (validTypes == null || validTypes.contains(ROUND)) {
                    nextStates.set(193);
                }
                if (validTypes == null || validTypes.contains(RANDOM)) {
                    nextStates.set(203);
                }
                if (validTypes == null || validTypes.contains(RELU)) {
                    nextStates.set(254);
                }
                if (validTypes == null || validTypes.contains(RANGE)) {
                    nextStates.set(273);
                }
                if (validTypes == null || validTypes.contains(REDUCE)) {
                    nextStates.set(296);
                }
            } else if (ch == 's') {
                if (validTypes == null || validTypes.contains(SIGN)) {
                    nextStates.set(92);
                }
                if (validTypes == null || validTypes.contains(SOFTMAX)) {
                    nextStates.set(111);
                }
                if (validTypes == null || validTypes.contains(SUM)) {
                    nextStates.set(141);
                }
                if (validTypes == null || validTypes.contains(SIN)) {
                    nextStates.set(152);
                }
                if (validTypes == null || validTypes.contains(SQUARE)) {
                    nextStates.set(177);
                }
                if (validTypes == null || validTypes.contains(SIGMOID)) {
                    nextStates.set(188);
                }
                if (validTypes == null || validTypes.contains(SINH)) {
                    nextStates.set(208);
                }
                if (validTypes == null || validTypes.contains(SQRT)) {
                    nextStates.set(277);
                }
            } else if (ch == 't') {
                if (validTypes == null || validTypes.contains(TAN)) {
                    nextStates.set(132);
                }
                if (validTypes == null || validTypes.contains(TENSOR)) {
                    nextStates.set(142);
                }
                if (validTypes == null || validTypes.contains(TANH)) {
                    nextStates.set(154);
                }
                if (validTypes == null || validTypes.contains(TRUE)) {
                    nextStates.set(223);
                }
            } else if (ch == 'u') {
                if (validTypes == null || validTypes.contains(UNPACK_BITS)) {
                    nextStates.set(229);
                }
            } else if (ch == 'x') {
                if (validTypes == null || validTypes.contains(XW_PLUS_B)) {
                    nextStates.set(125);
                }
            } else if (ch == '|') {
                if (validTypes == null || validTypes.contains(OR)) {
                    nextStates.set(82);
                }
            } else if (ch == '~') {
                if (validTypes == null || validTypes.contains(APPROX)) {
                    nextStates.set(33);
                }
            } else if (ch == '#') {
                if (validTypes == null || validTypes.contains(SINGLE_LINE_COMMENT)) {
                    nextStates.set(49);
                    type = SINGLE_LINE_COMMENT;
                }
            }
            if ((ch >= '0' && ch <= '9') || ((ch >= '@' && ch <= 'Z') || ((ch == '_') || (ch >= 'a' && ch <= 'z')))) {
                if (validTypes == null || validTypes.contains(IDENTIFIER)) {
                    nextStates.set(41);
                    type = IDENTIFIER;
                }
            }
            if (ch >= '0' && ch <= '9') {
                if (validTypes == null || validTypes.contains(FLOAT)) {
                    nextStates.set(6);
                    type = FLOAT;
                }
            }
            if (ch == '0') {
                if (validTypes == null || validTypes.contains(INTEGER)) {
                    nextStates.set(24);
                    type = INTEGER;
                }
            } else if (ch >= '1' && ch <= '9') {
                if (validTypes == null || validTypes.contains(INTEGER)) {
                    nextStates.set(55);
                    type = INTEGER;
                }
            } else if ((ch == '\t' || ch == '\n') || ((ch == '\r') || (ch == ' '))) {
                if (validTypes == null || validTypes.contains(_TOKEN_93)) {
                    type = _TOKEN_93;
                }
            } else if (ch == '!') {
                if (validTypes == null || validTypes.contains(NOT)) {
                    type = NOT;
                }
            } else if (ch == 'f') {
                if (validTypes == null || validTypes.contains(F)) {
                    type = F;
                }
            } else if (ch == '<') {
                if (validTypes == null || validTypes.contains(LESS)) {
                    type = LESS;
                }
            } else if (ch == '>') {
                if (validTypes == null || validTypes.contains(GREATER)) {
                    type = GREATER;
                }
            } else if (ch == ':') {
                if (validTypes == null || validTypes.contains(COLON)) {
                    type = COLON;
                }
            } else if (ch == ',') {
                if (validTypes == null || validTypes.contains(COMMA)) {
                    type = COMMA;
                }
            } else if (ch == '$') {
                if (validTypes == null || validTypes.contains(DOLLAR)) {
                    type = DOLLAR;
                }
            } else if (ch == '^') {
                if (validTypes == null || validTypes.contains(POWOP)) {
                    type = POWOP;
                }
            } else if (ch == '%') {
                if (validTypes == null || validTypes.contains(MOD)) {
                    type = MOD;
                }
            } else if (ch == '.') {
                if (validTypes == null || validTypes.contains(DOT)) {
                    type = DOT;
                }
            } else if (ch == '*') {
                if (validTypes == null || validTypes.contains(MUL)) {
                    type = MUL;
                }
            } else if (ch == '/') {
                if (validTypes == null || validTypes.contains(DIV)) {
                    type = DIV;
                }
            } else if (ch == '-') {
                if (validTypes == null || validTypes.contains(SUB)) {
                    type = SUB;
                }
            } else if (ch == '+') {
                if (validTypes == null || validTypes.contains(ADD)) {
                    type = ADD;
                }
            } else if (ch == '}') {
                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(RSQUARE)) {
                    type = RSQUARE;
                }
            } else if (ch == '[') {
                if (validTypes == null || validTypes.contains(LSQUARE)) {
                    type = LSQUARE;
                }
            } else if (ch == ')') {
                if (validTypes == null || validTypes.contains(RBRACE)) {
                    type = RBRACE;
                }
            } else if (ch == '(') {
                if (validTypes == null || validTypes.contains(LBRACE)) {
                    type = LBRACE;
                }
            }
            return type;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static TokenType getNfaIndex238(int ch, BitSet nextStates, EnumSet validTypes, EnumSet alreadyMatchedTypes) {
            if (ch == 'u') {
                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 == 'l') {
                nextStates.set(241);
            }
            return null;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }

}