/*******************************************************************************
 * Copyright (c) 1998, 2014 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation from Oracle TopLink
 ******************************************************************************/
// $ANTLR 3.0 JPQL.g 2010-05-03 16:14:54

    package org.eclipse.persistence.internal.jpa.parsing.jpql.antlr;

    import org.eclipse.persistence.internal.jpa.parsing.jpql.InvalidIdentifierStartException;


import org.eclipse.persistence.internal.libraries.antlr.runtime.*;

public class JPQLLexer extends Lexer {
    public static final int EXPONENT=116;
    public static final int FLOAT_SUFFIX=117;
    public static final int DATE_STRING=118;
    public static final int MOD=51;
    public static final int CURRENT_TIME=19;
    public static final int CASE=14;
    public static final int NEW=52;
    public static final int LEFT_ROUND_BRACKET=83;
    public static final int DOUBLE_LITERAL=98;
    public static final int TIME_LITERAL=102;
    public static final int COUNT=17;
    public static final int EQUALS=82;
    public static final int NOT=53;
    public static final int EOF=-1;
    public static final int TIME_STRING=119;
    public static final int TYPE=73;
    public static final int LEFT_CURLY_BRACKET=107;
    public static final int GREATER_THAN_EQUAL_TO=88;
    public static final int ESCAPE=28;
    public static final int NAMED_PARAM=105;
    public static final int BOTH=12;
    public static final int TIMESTAMP_LITERAL=103;
    public static final int NUMERIC_DIGITS=114;
    public static final int SELECT=61;
    public static final int DIVIDE=94;
    public static final int COALESCE=15;
    public static final int ASC=9;
    public static final int CONCAT=16;
    public static final int KEY=41;
    public static final int NULL=54;
    public static final int ELSE=24;
    public static final int TRAILING=69;
    public static final int DELETE=22;
    public static final int VALUE=77;
    public static final int DATE_LITERAL=101;
    public static final int OF=57;
    public static final int LEADING=42;
    public static final int RIGHT_CURLY_BRACKET=108;
    public static final int EMPTY=25;
    public static final int INTEGER_SUFFIX=112;
    public static final int ABS=4;
    public static final int GROUP=34;
    public static final int NOT_EQUAL_TO=86;
    public static final int WS=106;
    public static final int FETCH=31;
    public static final int STRING_LITERAL_SINGLE_QUOTED=100;
    public static final int INTEGER_LITERAL=95;
    public static final int FUNC=32;
    public static final int OR=58;
    public static final int TRIM=71;
    public static final int LESS_THAN=89;
    public static final int RIGHT_ROUND_BRACKET=84;
    public static final int POSITIONAL_PARAM=104;
    public static final int LOWER=47;
    public static final int FROM=33;
    public static final int END=26;
    public static final int FALSE=30;
    public static final int LESS_THAN_EQUAL_TO=90;
    public static final int DISTINCT=23;
    public static final int CURRENT_DATE=18;
    public static final int SIZE=63;
    public static final int UPPER=76;
    public static final int WHERE=79;
    public static final int NULLIF=55;
    public static final int MEMBER=49;
    public static final int INNER=38;
    public static final int ORDER=59;
    public static final int TEXTCHAR=109;
    public static final int MAX=48;
    public static final int UPDATE=75;
    public static final int AND=6;
    public static final int SUM=67;
    public static final int STRING_LITERAL_DOUBLE_QUOTED=99;
    public static final int LENGTH=44;
    public static final int INDEX=37;
    public static final int AS=8;
    public static final int IN=36;
    public static final int THEN=68;
    public static final int UNKNOWN=74;
    public static final int MULTIPLY=93;
    public static final int OBJECT=56;
    public static final int COMMA=81;
    public static final int IS=39;
    public static final int LEFT=43;
    public static final int AVG=10;
    public static final int SOME=65;
    public static final int ALL=5;
    public static final int IDENT=80;
    public static final int PLUS=91;
    public static final int HEX_LITERAL=111;
    public static final int EXISTS=29;
    public static final int DOT=85;
    public static final int CURRENT_TIMESTAMP=20;
    public static final int LIKE=45;
    public static final int OUTER=60;
    public static final int BY=13;
    public static final int GREATER_THAN=87;
    public static final int OCTAL_LITERAL=113;
    public static final int HEX_DIGIT=110;
    public static final int SET=62;
    public static final int HAVING=35;
    public static final int ENTRY=27;
    public static final int MIN=50;
    public static final int SQRT=64;
    public static final int MINUS=92;
    public static final int LONG_LITERAL=96;
    public static final int TRUE=72;
    public static final int JOIN=40;
    public static final int SUBSTRING=66;
    public static final int FLOAT_LITERAL=97;
    public static final int DOUBLE_SUFFIX=115;
    public static final int ANY=7;
    public static final int LOCATE=46;
    public static final int WHEN=78;
    public static final int DESC=21;
    public static final int BETWEEN=11;
    public static final int TREAT=70;

    // delegates
    // delegators

    public JPQLLexer() {;} 
    public JPQLLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public JPQLLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "JPQL.g"; }

    // $ANTLR start "ABS"
    public final void mABS() throws RecognitionException {
        try {
            int _type = ABS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:9:5: ( 'abs' )
            // JPQL.g:9:7: 'abs'
            {
            match("abs"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ABS"

    // $ANTLR start "ALL"
    public final void mALL() throws RecognitionException {
        try {
            int _type = ALL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:10:5: ( 'all' )
            // JPQL.g:10:7: 'all'
            {
            match("all"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ALL"

    // $ANTLR start "AND"
    public final void mAND() throws RecognitionException {
        try {
            int _type = AND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:11:5: ( 'and' )
            // JPQL.g:11:7: 'and'
            {
            match("and"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AND"

    // $ANTLR start "ANY"
    public final void mANY() throws RecognitionException {
        try {
            int _type = ANY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:12:5: ( 'any' )
            // JPQL.g:12:7: 'any'
            {
            match("any"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ANY"

    // $ANTLR start "AS"
    public final void mAS() throws RecognitionException {
        try {
            int _type = AS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:13:4: ( 'as' )
            // JPQL.g:13:6: 'as'
            {
            match("as"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AS"

    // $ANTLR start "ASC"
    public final void mASC() throws RecognitionException {
        try {
            int _type = ASC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:14:5: ( 'asc' )
            // JPQL.g:14:7: 'asc'
            {
            match("asc"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ASC"

    // $ANTLR start "AVG"
    public final void mAVG() throws RecognitionException {
        try {
            int _type = AVG;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:15:5: ( 'avg' )
            // JPQL.g:15:7: 'avg'
            {
            match("avg"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AVG"

    // $ANTLR start "BETWEEN"
    public final void mBETWEEN() throws RecognitionException {
        try {
            int _type = BETWEEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:16:9: ( 'between' )
            // JPQL.g:16:11: 'between'
            {
            match("between"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BETWEEN"

    // $ANTLR start "BOTH"
    public final void mBOTH() throws RecognitionException {
        try {
            int _type = BOTH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:17:6: ( 'both' )
            // JPQL.g:17:8: 'both'
            {
            match("both"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BOTH"

    // $ANTLR start "BY"
    public final void mBY() throws RecognitionException {
        try {
            int _type = BY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:18:4: ( 'by' )
            // JPQL.g:18:6: 'by'
            {
            match("by"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BY"

    // $ANTLR start "CASE"
    public final void mCASE() throws RecognitionException {
        try {
            int _type = CASE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:19:6: ( 'case' )
            // JPQL.g:19:8: 'case'
            {
            match("case"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CASE"

    // $ANTLR start "COALESCE"
    public final void mCOALESCE() throws RecognitionException {
        try {
            int _type = COALESCE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:20:10: ( 'coalesce' )
            // JPQL.g:20:12: 'coalesce'
            {
            match("coalesce"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COALESCE"

    // $ANTLR start "CONCAT"
    public final void mCONCAT() throws RecognitionException {
        try {
            int _type = CONCAT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:21:8: ( 'concat' )
            // JPQL.g:21:10: 'concat'
            {
            match("concat"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CONCAT"

    // $ANTLR start "COUNT"
    public final void mCOUNT() throws RecognitionException {
        try {
            int _type = COUNT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:22:7: ( 'count' )
            // JPQL.g:22:9: 'count'
            {
            match("count"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COUNT"

    // $ANTLR start "CURRENT_DATE"
    public final void mCURRENT_DATE() throws RecognitionException {
        try {
            int _type = CURRENT_DATE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:23:14: ( 'current_date' )
            // JPQL.g:23:16: 'current_date'
            {
            match("current_date"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CURRENT_DATE"

    // $ANTLR start "CURRENT_TIME"
    public final void mCURRENT_TIME() throws RecognitionException {
        try {
            int _type = CURRENT_TIME;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:24:14: ( 'current_time' )
            // JPQL.g:24:16: 'current_time'
            {
            match("current_time"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CURRENT_TIME"

    // $ANTLR start "CURRENT_TIMESTAMP"
    public final void mCURRENT_TIMESTAMP() throws RecognitionException {
        try {
            int _type = CURRENT_TIMESTAMP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:25:19: ( 'current_timestamp' )
            // JPQL.g:25:21: 'current_timestamp'
            {
            match("current_timestamp"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CURRENT_TIMESTAMP"

    // $ANTLR start "DESC"
    public final void mDESC() throws RecognitionException {
        try {
            int _type = DESC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:26:6: ( 'desc' )
            // JPQL.g:26:8: 'desc'
            {
            match("desc"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DESC"

    // $ANTLR start "DELETE"
    public final void mDELETE() throws RecognitionException {
        try {
            int _type = DELETE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:27:8: ( 'delete' )
            // JPQL.g:27:10: 'delete'
            {
            match("delete"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DELETE"

    // $ANTLR start "DISTINCT"
    public final void mDISTINCT() throws RecognitionException {
        try {
            int _type = DISTINCT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:28:10: ( 'distinct' )
            // JPQL.g:28:12: 'distinct'
            {
            match("distinct"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DISTINCT"

    // $ANTLR start "ELSE"
    public final void mELSE() throws RecognitionException {
        try {
            int _type = ELSE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:29:6: ( 'else' )
            // JPQL.g:29:8: 'else'
            {
            match("else"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ELSE"

    // $ANTLR start "EMPTY"
    public final void mEMPTY() throws RecognitionException {
        try {
            int _type = EMPTY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:30:7: ( 'empty' )
            // JPQL.g:30:9: 'empty'
            {
            match("empty"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EMPTY"

    // $ANTLR start "END"
    public final void mEND() throws RecognitionException {
        try {
            int _type = END;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:31:5: ( 'end' )
            // JPQL.g:31:7: 'end'
            {
            match("end"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "END"

    // $ANTLR start "ENTRY"
    public final void mENTRY() throws RecognitionException {
        try {
            int _type = ENTRY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:32:7: ( 'entry' )
            // JPQL.g:32:9: 'entry'
            {
            match("entry"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ENTRY"

    // $ANTLR start "ESCAPE"
    public final void mESCAPE() throws RecognitionException {
        try {
            int _type = ESCAPE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:33:8: ( 'escape' )
            // JPQL.g:33:10: 'escape'
            {
            match("escape"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ESCAPE"

    // $ANTLR start "EXISTS"
    public final void mEXISTS() throws RecognitionException {
        try {
            int _type = EXISTS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:34:8: ( 'exists' )
            // JPQL.g:34:10: 'exists'
            {
            match("exists"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EXISTS"

    // $ANTLR start "FALSE"
    public final void mFALSE() throws RecognitionException {
        try {
            int _type = FALSE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:35:7: ( 'false' )
            // JPQL.g:35:9: 'false'
            {
            match("false"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FALSE"

    // $ANTLR start "FETCH"
    public final void mFETCH() throws RecognitionException {
        try {
            int _type = FETCH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:36:7: ( 'fetch' )
            // JPQL.g:36:9: 'fetch'
            {
            match("fetch"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FETCH"

    // $ANTLR start "FUNC"
    public final void mFUNC() throws RecognitionException {
        try {
            int _type = FUNC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:37:6: ( 'func' )
            // JPQL.g:37:8: 'func'
            {
            match("func"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FUNC"

    // $ANTLR start "FROM"
    public final void mFROM() throws RecognitionException {
        try {
            int _type = FROM;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:38:6: ( 'from' )
            // JPQL.g:38:8: 'from'
            {
            match("from"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FROM"

    // $ANTLR start "GROUP"
    public final void mGROUP() throws RecognitionException {
        try {
            int _type = GROUP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:39:7: ( 'group' )
            // JPQL.g:39:9: 'group'
            {
            match("group"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GROUP"

    // $ANTLR start "HAVING"
    public final void mHAVING() throws RecognitionException {
        try {
            int _type = HAVING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:40:8: ( 'having' )
            // JPQL.g:40:10: 'having'
            {
            match("having"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "HAVING"

    // $ANTLR start "IN"
    public final void mIN() throws RecognitionException {
        try {
            int _type = IN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:41:4: ( 'in' )
            // JPQL.g:41:6: 'in'
            {
            match("in"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IN"

    // $ANTLR start "INDEX"
    public final void mINDEX() throws RecognitionException {
        try {
            int _type = INDEX;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:42:7: ( 'index' )
            // JPQL.g:42:9: 'index'
            {
            match("index"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INDEX"

    // $ANTLR start "INNER"
    public final void mINNER() throws RecognitionException {
        try {
            int _type = INNER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:43:7: ( 'inner' )
            // JPQL.g:43:9: 'inner'
            {
            match("inner"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INNER"

    // $ANTLR start "IS"
    public final void mIS() throws RecognitionException {
        try {
            int _type = IS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:44:4: ( 'is' )
            // JPQL.g:44:6: 'is'
            {
            match("is"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IS"

    // $ANTLR start "JOIN"
    public final void mJOIN() throws RecognitionException {
        try {
            int _type = JOIN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:45:6: ( 'join' )
            // JPQL.g:45:8: 'join'
            {
            match("join"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "JOIN"

    // $ANTLR start "KEY"
    public final void mKEY() throws RecognitionException {
        try {
            int _type = KEY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:46:5: ( 'key' )
            // JPQL.g:46:7: 'key'
            {
            match("key"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "KEY"

    // $ANTLR start "LEADING"
    public final void mLEADING() throws RecognitionException {
        try {
            int _type = LEADING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:47:9: ( 'leading' )
            // JPQL.g:47:11: 'leading'
            {
            match("leading"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LEADING"

    // $ANTLR start "LEFT"
    public final void mLEFT() throws RecognitionException {
        try {
            int _type = LEFT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:48:6: ( 'left' )
            // JPQL.g:48:8: 'left'
            {
            match("left"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LEFT"

    // $ANTLR start "LENGTH"
    public final void mLENGTH() throws RecognitionException {
        try {
            int _type = LENGTH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:49:8: ( 'length' )
            // JPQL.g:49:10: 'length'
            {
            match("length"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LENGTH"

    // $ANTLR start "LIKE"
    public final void mLIKE() throws RecognitionException {
        try {
            int _type = LIKE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:50:6: ( 'like' )
            // JPQL.g:50:8: 'like'
            {
            match("like"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LIKE"

    // $ANTLR start "LOCATE"
    public final void mLOCATE() throws RecognitionException {
        try {
            int _type = LOCATE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:51:8: ( 'locate' )
            // JPQL.g:51:10: 'locate'
            {
            match("locate"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LOCATE"

    // $ANTLR start "LOWER"
    public final void mLOWER() throws RecognitionException {
        try {
            int _type = LOWER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:52:7: ( 'lower' )
            // JPQL.g:52:9: 'lower'
            {
            match("lower"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LOWER"

    // $ANTLR start "MAX"
    public final void mMAX() throws RecognitionException {
        try {
            int _type = MAX;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:53:5: ( 'max' )
            // JPQL.g:53:7: 'max'
            {
            match("max"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MAX"

    // $ANTLR start "MEMBER"
    public final void mMEMBER() throws RecognitionException {
        try {
            int _type = MEMBER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:54:8: ( 'member' )
            // JPQL.g:54:10: 'member'
            {
            match("member"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MEMBER"

    // $ANTLR start "MIN"
    public final void mMIN() throws RecognitionException {
        try {
            int _type = MIN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:55:5: ( 'min' )
            // JPQL.g:55:7: 'min'
            {
            match("min"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MIN"

    // $ANTLR start "MOD"
    public final void mMOD() throws RecognitionException {
        try {
            int _type = MOD;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:56:5: ( 'mod' )
            // JPQL.g:56:7: 'mod'
            {
            match("mod"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MOD"

    // $ANTLR start "NEW"
    public final void mNEW() throws RecognitionException {
        try {
            int _type = NEW;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:57:5: ( 'new' )
            // JPQL.g:57:7: 'new'
            {
            match("new"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NEW"

    // $ANTLR start "NOT"
    public final void mNOT() throws RecognitionException {
        try {
            int _type = NOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:58:5: ( 'not' )
            // JPQL.g:58:7: 'not'
            {
            match("not"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NOT"

    // $ANTLR start "NULL"
    public final void mNULL() throws RecognitionException {
        try {
            int _type = NULL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:59:6: ( 'null' )
            // JPQL.g:59:8: 'null'
            {
            match("null"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NULL"

    // $ANTLR start "NULLIF"
    public final void mNULLIF() throws RecognitionException {
        try {
            int _type = NULLIF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:60:8: ( 'nullif' )
            // JPQL.g:60:10: 'nullif'
            {
            match("nullif"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NULLIF"

    // $ANTLR start "OBJECT"
    public final void mOBJECT() throws RecognitionException {
        try {
            int _type = OBJECT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:61:8: ( 'object' )
            // JPQL.g:61:10: 'object'
            {
            match("object"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OBJECT"

    // $ANTLR start "OF"
    public final void mOF() throws RecognitionException {
        try {
            int _type = OF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:62:4: ( 'of' )
            // JPQL.g:62:6: 'of'
            {
            match("of"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OF"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:63:4: ( 'or' )
            // JPQL.g:63:6: 'or'
            {
            match("or"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "ORDER"
    public final void mORDER() throws RecognitionException {
        try {
            int _type = ORDER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:64:7: ( 'order' )
            // JPQL.g:64:9: 'order'
            {
            match("order"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ORDER"

    // $ANTLR start "OUTER"
    public final void mOUTER() throws RecognitionException {
        try {
            int _type = OUTER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:65:7: ( 'outer' )
            // JPQL.g:65:9: 'outer'
            {
            match("outer"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OUTER"

    // $ANTLR start "SELECT"
    public final void mSELECT() throws RecognitionException {
        try {
            int _type = SELECT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:66:8: ( 'select' )
            // JPQL.g:66:10: 'select'
            {
            match("select"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SELECT"

    // $ANTLR start "SET"
    public final void mSET() throws RecognitionException {
        try {
            int _type = SET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:67:5: ( 'set' )
            // JPQL.g:67:7: 'set'
            {
            match("set"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SET"

    // $ANTLR start "SIZE"
    public final void mSIZE() throws RecognitionException {
        try {
            int _type = SIZE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:68:6: ( 'size' )
            // JPQL.g:68:8: 'size'
            {
            match("size"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SIZE"

    // $ANTLR start "SQRT"
    public final void mSQRT() throws RecognitionException {
        try {
            int _type = SQRT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:69:6: ( 'sqrt' )
            // JPQL.g:69:8: 'sqrt'
            {
            match("sqrt"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SQRT"

    // $ANTLR start "SOME"
    public final void mSOME() throws RecognitionException {
        try {
            int _type = SOME;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:70:6: ( 'some' )
            // JPQL.g:70:8: 'some'
            {
            match("some"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SOME"

    // $ANTLR start "SUBSTRING"
    public final void mSUBSTRING() throws RecognitionException {
        try {
            int _type = SUBSTRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:71:11: ( 'substring' )
            // JPQL.g:71:13: 'substring'
            {
            match("substring"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SUBSTRING"

    // $ANTLR start "SUM"
    public final void mSUM() throws RecognitionException {
        try {
            int _type = SUM;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:72:5: ( 'sum' )
            // JPQL.g:72:7: 'sum'
            {
            match("sum"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SUM"

    // $ANTLR start "THEN"
    public final void mTHEN() throws RecognitionException {
        try {
            int _type = THEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:73:6: ( 'then' )
            // JPQL.g:73:8: 'then'
            {
            match("then"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "THEN"

    // $ANTLR start "TRAILING"
    public final void mTRAILING() throws RecognitionException {
        try {
            int _type = TRAILING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:74:10: ( 'trailing' )
            // JPQL.g:74:12: 'trailing'
            {
            match("trailing"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TRAILING"

    // $ANTLR start "TREAT"
    public final void mTREAT() throws RecognitionException {
        try {
            int _type = TREAT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:75:7: ( 'treat' )
            // JPQL.g:75:9: 'treat'
            {
            match("treat"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TREAT"

    // $ANTLR start "TRIM"
    public final void mTRIM() throws RecognitionException {
        try {
            int _type = TRIM;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:76:6: ( 'trim' )
            // JPQL.g:76:8: 'trim'
            {
            match("trim"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TRIM"

    // $ANTLR start "TRUE"
    public final void mTRUE() throws RecognitionException {
        try {
            int _type = TRUE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:77:6: ( 'true' )
            // JPQL.g:77:8: 'true'
            {
            match("true"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TRUE"

    // $ANTLR start "TYPE"
    public final void mTYPE() throws RecognitionException {
        try {
            int _type = TYPE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:78:6: ( 'type' )
            // JPQL.g:78:8: 'type'
            {
            match("type"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TYPE"

    // $ANTLR start "UNKNOWN"
    public final void mUNKNOWN() throws RecognitionException {
        try {
            int _type = UNKNOWN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:79:9: ( 'unknown' )
            // JPQL.g:79:11: 'unknown'
            {
            match("unknown"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UNKNOWN"

    // $ANTLR start "UPDATE"
    public final void mUPDATE() throws RecognitionException {
        try {
            int _type = UPDATE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:80:8: ( 'update' )
            // JPQL.g:80:10: 'update'
            {
            match("update"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UPDATE"

    // $ANTLR start "UPPER"
    public final void mUPPER() throws RecognitionException {
        try {
            int _type = UPPER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:81:7: ( 'upper' )
            // JPQL.g:81:9: 'upper'
            {
            match("upper"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UPPER"

    // $ANTLR start "VALUE"
    public final void mVALUE() throws RecognitionException {
        try {
            int _type = VALUE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:82:7: ( 'value' )
            // JPQL.g:82:9: 'value'
            {
            match("value"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "VALUE"

    // $ANTLR start "WHEN"
    public final void mWHEN() throws RecognitionException {
        try {
            int _type = WHEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:83:6: ( 'when' )
            // JPQL.g:83:8: 'when'
            {
            match("when"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WHEN"

    // $ANTLR start "WHERE"
    public final void mWHERE() throws RecognitionException {
        try {
            int _type = WHERE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:84:7: ( 'where' )
            // JPQL.g:84:9: 'where'
            {
            match("where"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WHERE"

    // $ANTLR start "DOT"
    public final void mDOT() throws RecognitionException {
        try {
            int _type = DOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1394:5: ( '.' )
            // JPQL.g:1394:7: '.'
            {
            match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DOT"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1397:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
            // JPQL.g:1397:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
            {
            // JPQL.g:1397:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( ((LA1_0>='\t' && LA1_0<='\n')||LA1_0=='\r'||LA1_0==' ') ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // JPQL.g:
            	    {
            	    if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);

             skip(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WS"

    // $ANTLR start "LEFT_ROUND_BRACKET"
    public final void mLEFT_ROUND_BRACKET() throws RecognitionException {
        try {
            int _type = LEFT_ROUND_BRACKET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1401:5: ( '(' )
            // JPQL.g:1401:7: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LEFT_ROUND_BRACKET"

    // $ANTLR start "LEFT_CURLY_BRACKET"
    public final void mLEFT_CURLY_BRACKET() throws RecognitionException {
        try {
            int _type = LEFT_CURLY_BRACKET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1405:5: ( '{' )
            // JPQL.g:1405:7: '{'
            {
            match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LEFT_CURLY_BRACKET"

    // $ANTLR start "RIGHT_ROUND_BRACKET"
    public final void mRIGHT_ROUND_BRACKET() throws RecognitionException {
        try {
            int _type = RIGHT_ROUND_BRACKET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1409:5: ( ')' )
            // JPQL.g:1409:7: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RIGHT_ROUND_BRACKET"

    // $ANTLR start "RIGHT_CURLY_BRACKET"
    public final void mRIGHT_CURLY_BRACKET() throws RecognitionException {
        try {
            int _type = RIGHT_CURLY_BRACKET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1413:5: ( '}' )
            // JPQL.g:1413:7: '}'
            {
            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RIGHT_CURLY_BRACKET"

    // $ANTLR start "COMMA"
    public final void mCOMMA() throws RecognitionException {
        try {
            int _type = COMMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1417:5: ( ',' )
            // JPQL.g:1417:7: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMMA"

    // $ANTLR start "IDENT"
    public final void mIDENT() throws RecognitionException {
        try {
            int _type = IDENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1421:5: ( TEXTCHAR )
            // JPQL.g:1421:7: TEXTCHAR
            {
            mTEXTCHAR(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IDENT"

    // $ANTLR start "TEXTCHAR"
    public final void mTEXTCHAR() throws RecognitionException {
        try {
            int c1;
            int c2;

            // JPQL.g:1426:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '$' | '`' | '~' | '@' | '#' | '%' | '^' | '&' | '|' | '[' | ']' | ';' c1= '\\u0080' .. '\\uFFFE' ) ( 'a' .. 'z' | '_' | '$' | '0' .. '9' | c2= '\\u0080' .. '\\uFFFE' )* )
            // JPQL.g:1426:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '$' | '`' | '~' | '@' | '#' | '%' | '^' | '&' | '|' | '[' | ']' | ';' c1= '\\u0080' .. '\\uFFFE' ) ( 'a' .. 'z' | '_' | '$' | '0' .. '9' | c2= '\\u0080' .. '\\uFFFE' )*
            {
            // JPQL.g:1426:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '$' | '`' | '~' | '@' | '#' | '%' | '^' | '&' | '|' | '[' | ']' | ';' c1= '\\u0080' .. '\\uFFFE' )
            int alt2=15;
            switch ( input.LA(1) ) {
            case 'a':
            case 'b':
            case 'c':
            case 'd':
            case 'e':
            case 'f':
            case 'g':
            case 'h':
            case 'i':
            case 'j':
            case 'k':
            case 'l':
            case 'm':
            case 'n':
            case 'o':
            case 'p':
            case 'q':
            case 'r':
            case 's':
            case 't':
            case 'u':
            case 'v':
            case 'w':
            case 'x':
            case 'y':
            case 'z':
                {
                alt2=1;
                }
                break;
            case 'A':
            case 'B':
            case 'C':
            case 'D':
            case 'E':
            case 'F':
            case 'G':
            case 'H':
            case 'I':
            case 'J':
            case 'K':
            case 'L':
            case 'M':
            case 'N':
            case 'O':
            case 'P':
            case 'Q':
            case 'R':
            case 'S':
            case 'T':
            case 'U':
            case 'V':
            case 'W':
            case 'X':
            case 'Y':
            case 'Z':
                {
                alt2=2;
                }
                break;
            case '_':
                {
                alt2=3;
                }
                break;
            case '$':
                {
                alt2=4;
                }
                break;
            case '`':
                {
                alt2=5;
                }
                break;
            case '~':
                {
                alt2=6;
                }
                break;
            case '@':
                {
                alt2=7;
                }
                break;
            case '#':
                {
                alt2=8;
                }
                break;
            case '%':
                {
                alt2=9;
                }
                break;
            case '^':
                {
                alt2=10;
                }
                break;
            case '&':
                {
                alt2=11;
                }
                break;
            case '|':
                {
                alt2=12;
                }
                break;
            case '[':
                {
                alt2=13;
                }
                break;
            case ']':
                {
                alt2=14;
                }
                break;
            case ';':
                {
                alt2=15;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }

            switch (alt2) {
                case 1 :
                    // JPQL.g:1426:8: 'a' .. 'z'
                    {
                    matchRange('a','z'); 

                    }
                    break;
                case 2 :
                    // JPQL.g:1426:19: 'A' .. 'Z'
                    {
                    matchRange('A','Z'); 

                    }
                    break;
                case 3 :
                    // JPQL.g:1426:30: '_'
                    {
                    match('_'); 

                    }
                    break;
                case 4 :
                    // JPQL.g:1426:36: '$'
                    {
                    match('$'); 

                    }
                    break;
                case 5 :
                    // JPQL.g:1426:42: '`'
                    {
                    match('`'); 

                    }
                    break;
                case 6 :
                    // JPQL.g:1426:48: '~'
                    {
                    match('~'); 

                    }
                    break;
                case 7 :
                    // JPQL.g:1426:54: '@'
                    {
                    match('@'); 

                    }
                    break;
                case 8 :
                    // JPQL.g:1426:60: '#'
                    {
                    match('#'); 

                    }
                    break;
                case 9 :
                    // JPQL.g:1426:66: '%'
                    {
                    match('%'); 

                    }
                    break;
                case 10 :
                    // JPQL.g:1426:72: '^'
                    {
                    match('^'); 

                    }
                    break;
                case 11 :
                    // JPQL.g:1426:78: '&'
                    {
                    match('&'); 

                    }
                    break;
                case 12 :
                    // JPQL.g:1426:84: '|'
                    {
                    match('|'); 

                    }
                    break;
                case 13 :
                    // JPQL.g:1426:90: '['
                    {
                    match('['); 

                    }
                    break;
                case 14 :
                    // JPQL.g:1426:96: ']'
                    {
                    match(']'); 

                    }
                    break;
                case 15 :
                    // JPQL.g:1426:102: ';' c1= '\\u0080' .. '\\uFFFE'
                    {
                    match(';'); 
                    c1 = input.LA(1);
                    matchRange('\u0080','\uFFFE'); 

                               if (!Character.isJavaIdentifierStart(c1)) {
                                    throw new InvalidIdentifierStartException(c1, getLine(), getCharPositionInLine());
                               }
                           

                    }
                    break;

            }

            // JPQL.g:1434:7: ( 'a' .. 'z' | '_' | '$' | '0' .. '9' | c2= '\\u0080' .. '\\uFFFE' )*
            loop3:
            do {
                int alt3=6;
                int LA3_0 = input.LA(1);

                if ( ((LA3_0>='a' && LA3_0<='z')) ) {
                    alt3=1;
                }
                else if ( (LA3_0=='_') ) {
                    alt3=2;
                }
                else if ( (LA3_0=='$') ) {
                    alt3=3;
                }
                else if ( ((LA3_0>='0' && LA3_0<='9')) ) {
                    alt3=4;
                }
                else if ( ((LA3_0>='\u0080' && LA3_0<='\uFFFE')) ) {
                    alt3=5;
                }


                switch (alt3) {
            	case 1 :
            	    // JPQL.g:1434:8: 'a' .. 'z'
            	    {
            	    matchRange('a','z'); 

            	    }
            	    break;
            	case 2 :
            	    // JPQL.g:1434:19: '_'
            	    {
            	    match('_'); 

            	    }
            	    break;
            	case 3 :
            	    // JPQL.g:1434:25: '$'
            	    {
            	    match('$'); 

            	    }
            	    break;
            	case 4 :
            	    // JPQL.g:1434:31: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;
            	case 5 :
            	    // JPQL.g:1435:8: c2= '\\u0080' .. '\\uFFFE'
            	    {
            	    c2 = input.LA(1);
            	    matchRange('\u0080','\uFFFE'); 

            	               if (!Character.isJavaIdentifierPart(c2)) {
            	                    throw new InvalidIdentifierStartException(c2, getLine(), getCharPositionInLine());
            	               }
            	           

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);


            }

        }
        finally {
        }
    }
    // $ANTLR end "TEXTCHAR"

    // $ANTLR start "HEX_LITERAL"
    public final void mHEX_LITERAL() throws RecognitionException {
        try {
            int _type = HEX_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1445:13: ( '0' ( 'x' | 'X' ) ( HEX_DIGIT )+ )
            // JPQL.g:1445:15: '0' ( 'x' | 'X' ) ( HEX_DIGIT )+
            {
            match('0'); 
            if ( input.LA(1)=='X'||input.LA(1)=='x' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // JPQL.g:1445:29: ( HEX_DIGIT )+
            int cnt4=0;
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='F')||(LA4_0>='a' && LA4_0<='f')) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // JPQL.g:1445:29: HEX_DIGIT
            	    {
            	    mHEX_DIGIT(); 

            	    }
            	    break;

            	default :
            	    if ( cnt4 >= 1 ) break loop4;
                        EarlyExitException eee =
                            new EarlyExitException(4, input);
                        throw eee;
                }
                cnt4++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "HEX_LITERAL"

    // $ANTLR start "INTEGER_LITERAL"
    public final void mINTEGER_LITERAL() throws RecognitionException {
        try {
            int _type = INTEGER_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1447:17: ( ( MINUS )? ( '0' | '1' .. '9' ( '0' .. '9' )* ) )
            // JPQL.g:1447:19: ( MINUS )? ( '0' | '1' .. '9' ( '0' .. '9' )* )
            {
            // JPQL.g:1447:19: ( MINUS )?
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0=='-') ) {
                alt5=1;
            }
            switch (alt5) {
                case 1 :
                    // JPQL.g:1447:19: MINUS
                    {
                    mMINUS(); 

                    }
                    break;

            }

            // JPQL.g:1447:26: ( '0' | '1' .. '9' ( '0' .. '9' )* )
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0=='0') ) {
                alt7=1;
            }
            else if ( ((LA7_0>='1' && LA7_0<='9')) ) {
                alt7=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;
            }
            switch (alt7) {
                case 1 :
                    // JPQL.g:1447:27: '0'
                    {
                    match('0'); 

                    }
                    break;
                case 2 :
                    // JPQL.g:1447:33: '1' .. '9' ( '0' .. '9' )*
                    {
                    matchRange('1','9'); 
                    // JPQL.g:1447:42: ( '0' .. '9' )*
                    loop6:
                    do {
                        int alt6=2;
                        int LA6_0 = input.LA(1);

                        if ( ((LA6_0>='0' && LA6_0<='9')) ) {
                            alt6=1;
                        }


                        switch (alt6) {
                    	case 1 :
                    	    // JPQL.g:1447:42: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop6;
                        }
                    } while (true);


                    }
                    break;

            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INTEGER_LITERAL"

    // $ANTLR start "LONG_LITERAL"
    public final void mLONG_LITERAL() throws RecognitionException {
        try {
            int _type = LONG_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1449:14: ( INTEGER_LITERAL INTEGER_SUFFIX )
            // JPQL.g:1449:16: INTEGER_LITERAL INTEGER_SUFFIX
            {
            mINTEGER_LITERAL(); 
            mINTEGER_SUFFIX(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LONG_LITERAL"

    // $ANTLR start "OCTAL_LITERAL"
    public final void mOCTAL_LITERAL() throws RecognitionException {
        try {
            int _type = OCTAL_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1451:15: ( ( MINUS )? '0' ( '0' .. '7' )+ )
            // JPQL.g:1451:17: ( MINUS )? '0' ( '0' .. '7' )+
            {
            // JPQL.g:1451:17: ( MINUS )?
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0=='-') ) {
                alt8=1;
            }
            switch (alt8) {
                case 1 :
                    // JPQL.g:1451:17: MINUS
                    {
                    mMINUS(); 

                    }
                    break;

            }

            match('0'); 
            // JPQL.g:1451:28: ( '0' .. '7' )+
            int cnt9=0;
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( ((LA9_0>='0' && LA9_0<='7')) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // JPQL.g:1451:29: '0' .. '7'
            	    {
            	    matchRange('0','7'); 

            	    }
            	    break;

            	default :
            	    if ( cnt9 >= 1 ) break loop9;
                        EarlyExitException eee =
                            new EarlyExitException(9, input);
                        throw eee;
                }
                cnt9++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OCTAL_LITERAL"

    // $ANTLR start "HEX_DIGIT"
    public final void mHEX_DIGIT() throws RecognitionException {
        try {
            // JPQL.g:1456:5: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
            // JPQL.g:1456:9: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
            {
            if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

        }
        finally {
        }
    }
    // $ANTLR end "HEX_DIGIT"

    // $ANTLR start "INTEGER_SUFFIX"
    public final void mINTEGER_SUFFIX() throws RecognitionException {
        try {
            // JPQL.g:1460:16: ( ( 'l' | 'L' ) )
            // JPQL.g:1460:18: ( 'l' | 'L' )
            {
            if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

        }
        finally {
        }
    }
    // $ANTLR end "INTEGER_SUFFIX"

    // $ANTLR start "NUMERIC_DIGITS"
    public final void mNUMERIC_DIGITS() throws RecognitionException {
        try {
            // JPQL.g:1464:5: ( ( MINUS )? ( '0' .. '9' )+ '.' ( '0' .. '9' )* | ( MINUS )? '.' ( '0' .. '9' )+ | ( MINUS )? ( '0' .. '9' )+ )
            int alt17=3;
            alt17 = dfa17.predict(input);
            switch (alt17) {
                case 1 :
                    // JPQL.g:1464:9: ( MINUS )? ( '0' .. '9' )+ '.' ( '0' .. '9' )*
                    {
                    // JPQL.g:1464:9: ( MINUS )?
                    int alt10=2;
                    int LA10_0 = input.LA(1);

                    if ( (LA10_0=='-') ) {
                        alt10=1;
                    }
                    switch (alt10) {
                        case 1 :
                            // JPQL.g:1464:9: MINUS
                            {
                            mMINUS(); 

                            }
                            break;

                    }

                    // JPQL.g:1464:16: ( '0' .. '9' )+
                    int cnt11=0;
                    loop11:
                    do {
                        int alt11=2;
                        int LA11_0 = input.LA(1);

                        if ( ((LA11_0>='0' && LA11_0<='9')) ) {
                            alt11=1;
                        }


                        switch (alt11) {
                    	case 1 :
                    	    // JPQL.g:1464:17: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt11 >= 1 ) break loop11;
                                EarlyExitException eee =
                                    new EarlyExitException(11, input);
                                throw eee;
                        }
                        cnt11++;
                    } while (true);

                    match('.'); 
                    // JPQL.g:1464:32: ( '0' .. '9' )*
                    loop12:
                    do {
                        int alt12=2;
                        int LA12_0 = input.LA(1);

                        if ( ((LA12_0>='0' && LA12_0<='9')) ) {
                            alt12=1;
                        }


                        switch (alt12) {
                    	case 1 :
                    	    // JPQL.g:1464:33: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop12;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // JPQL.g:1465:9: ( MINUS )? '.' ( '0' .. '9' )+
                    {
                    // JPQL.g:1465:9: ( MINUS )?
                    int alt13=2;
                    int LA13_0 = input.LA(1);

                    if ( (LA13_0=='-') ) {
                        alt13=1;
                    }
                    switch (alt13) {
                        case 1 :
                            // JPQL.g:1465:9: MINUS
                            {
                            mMINUS(); 

                            }
                            break;

                    }

                    match('.'); 
                    // JPQL.g:1465:20: ( '0' .. '9' )+
                    int cnt14=0;
                    loop14:
                    do {
                        int alt14=2;
                        int LA14_0 = input.LA(1);

                        if ( ((LA14_0>='0' && LA14_0<='9')) ) {
                            alt14=1;
                        }


                        switch (alt14) {
                    	case 1 :
                    	    // JPQL.g:1465:21: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt14 >= 1 ) break loop14;
                                EarlyExitException eee =
                                    new EarlyExitException(14, input);
                                throw eee;
                        }
                        cnt14++;
                    } while (true);


                    }
                    break;
                case 3 :
                    // JPQL.g:1466:9: ( MINUS )? ( '0' .. '9' )+
                    {
                    // JPQL.g:1466:9: ( MINUS )?
                    int alt15=2;
                    int LA15_0 = input.LA(1);

                    if ( (LA15_0=='-') ) {
                        alt15=1;
                    }
                    switch (alt15) {
                        case 1 :
                            // JPQL.g:1466:9: MINUS
                            {
                            mMINUS(); 

                            }
                            break;

                    }

                    // JPQL.g:1466:16: ( '0' .. '9' )+
                    int cnt16=0;
                    loop16:
                    do {
                        int alt16=2;
                        int LA16_0 = input.LA(1);

                        if ( ((LA16_0>='0' && LA16_0<='9')) ) {
                            alt16=1;
                        }


                        switch (alt16) {
                    	case 1 :
                    	    // JPQL.g:1466:17: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt16 >= 1 ) break loop16;
                                EarlyExitException eee =
                                    new EarlyExitException(16, input);
                                throw eee;
                        }
                        cnt16++;
                    } while (true);


                    }
                    break;

            }
        }
        finally {
        }
    }
    // $ANTLR end "NUMERIC_DIGITS"

    // $ANTLR start "DOUBLE_LITERAL"
    public final void mDOUBLE_LITERAL() throws RecognitionException {
        try {
            int _type = DOUBLE_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1470:5: ( NUMERIC_DIGITS ( DOUBLE_SUFFIX )? )
            // JPQL.g:1470:9: NUMERIC_DIGITS ( DOUBLE_SUFFIX )?
            {
            mNUMERIC_DIGITS(); 
            // JPQL.g:1470:24: ( DOUBLE_SUFFIX )?
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0=='d') ) {
                alt18=1;
            }
            switch (alt18) {
                case 1 :
                    // JPQL.g:1470:24: DOUBLE_SUFFIX
                    {
                    mDOUBLE_SUFFIX(); 

                    }
                    break;

            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DOUBLE_LITERAL"

    // $ANTLR start "FLOAT_LITERAL"
    public final void mFLOAT_LITERAL() throws RecognitionException {
        try {
            int _type = FLOAT_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1474:5: ( NUMERIC_DIGITS EXPONENT ( FLOAT_SUFFIX )? | NUMERIC_DIGITS FLOAT_SUFFIX )
            int alt20=2;
            alt20 = dfa20.predict(input);
            switch (alt20) {
                case 1 :
                    // JPQL.g:1474:9: NUMERIC_DIGITS EXPONENT ( FLOAT_SUFFIX )?
                    {
                    mNUMERIC_DIGITS(); 
                    mEXPONENT(); 
                    // JPQL.g:1474:33: ( FLOAT_SUFFIX )?
                    int alt19=2;
                    int LA19_0 = input.LA(1);

                    if ( (LA19_0=='f') ) {
                        alt19=1;
                    }
                    switch (alt19) {
                        case 1 :
                            // JPQL.g:1474:33: FLOAT_SUFFIX
                            {
                            mFLOAT_SUFFIX(); 

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // JPQL.g:1475:9: NUMERIC_DIGITS FLOAT_SUFFIX
                    {
                    mNUMERIC_DIGITS(); 
                    mFLOAT_SUFFIX(); 

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FLOAT_LITERAL"

    // $ANTLR start "EXPONENT"
    public final void mEXPONENT() throws RecognitionException {
        try {
            // JPQL.g:1481:5: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )
            // JPQL.g:1481:9: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+
            {
            if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // JPQL.g:1481:21: ( '+' | '-' )?
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( (LA21_0=='+'||LA21_0=='-') ) {
                alt21=1;
            }
            switch (alt21) {
                case 1 :
                    // JPQL.g:
                    {
                    if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;

            }

            // JPQL.g:1481:32: ( '0' .. '9' )+
            int cnt22=0;
            loop22:
            do {
                int alt22=2;
                int LA22_0 = input.LA(1);

                if ( ((LA22_0>='0' && LA22_0<='9')) ) {
                    alt22=1;
                }


                switch (alt22) {
            	case 1 :
            	    // JPQL.g:1481:33: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    if ( cnt22 >= 1 ) break loop22;
                        EarlyExitException eee =
                            new EarlyExitException(22, input);
                        throw eee;
                }
                cnt22++;
            } while (true);


            }

        }
        finally {
        }
    }
    // $ANTLR end "EXPONENT"

    // $ANTLR start "FLOAT_SUFFIX"
    public final void mFLOAT_SUFFIX() throws RecognitionException {
        try {
            // JPQL.g:1487:5: ( 'f' )
            // JPQL.g:1487:9: 'f'
            {
            match('f'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "FLOAT_SUFFIX"

    // $ANTLR start "DATE_LITERAL"
    public final void mDATE_LITERAL() throws RecognitionException {
        try {
            int _type = DATE_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1491:5: ( LEFT_CURLY_BRACKET ( 'd' ) ( ' ' | '\\t' )+ '\\'' DATE_STRING '\\'' ( ' ' | '\\t' )* RIGHT_CURLY_BRACKET )
            // JPQL.g:1491:7: LEFT_CURLY_BRACKET ( 'd' ) ( ' ' | '\\t' )+ '\\'' DATE_STRING '\\'' ( ' ' | '\\t' )* RIGHT_CURLY_BRACKET
            {
            mLEFT_CURLY_BRACKET(); 
            // JPQL.g:1491:26: ( 'd' )
            // JPQL.g:1491:27: 'd'
            {
            match('d'); 

            }

            // JPQL.g:1491:32: ( ' ' | '\\t' )+
            int cnt23=0;
            loop23:
            do {
                int alt23=2;
                int LA23_0 = input.LA(1);

                if ( (LA23_0=='\t'||LA23_0==' ') ) {
                    alt23=1;
                }


                switch (alt23) {
            	case 1 :
            	    // JPQL.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt23 >= 1 ) break loop23;
                        EarlyExitException eee =
                            new EarlyExitException(23, input);
                        throw eee;
                }
                cnt23++;
            } while (true);

            match('\''); 
            mDATE_STRING(); 
            match('\''); 
            // JPQL.g:1491:68: ( ' ' | '\\t' )*
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( (LA24_0=='\t'||LA24_0==' ') ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // JPQL.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop24;
                }
            } while (true);

            mRIGHT_CURLY_BRACKET(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DATE_LITERAL"

    // $ANTLR start "TIME_LITERAL"
    public final void mTIME_LITERAL() throws RecognitionException {
        try {
            int _type = TIME_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1495:5: ( LEFT_CURLY_BRACKET ( 't' ) ( ' ' | '\\t' )+ '\\'' TIME_STRING '\\'' ( ' ' | '\\t' )* RIGHT_CURLY_BRACKET )
            // JPQL.g:1495:7: LEFT_CURLY_BRACKET ( 't' ) ( ' ' | '\\t' )+ '\\'' TIME_STRING '\\'' ( ' ' | '\\t' )* RIGHT_CURLY_BRACKET
            {
            mLEFT_CURLY_BRACKET(); 
            // JPQL.g:1495:26: ( 't' )
            // JPQL.g:1495:27: 't'
            {
            match('t'); 

            }

            // JPQL.g:1495:32: ( ' ' | '\\t' )+
            int cnt25=0;
            loop25:
            do {
                int alt25=2;
                int LA25_0 = input.LA(1);

                if ( (LA25_0=='\t'||LA25_0==' ') ) {
                    alt25=1;
                }


                switch (alt25) {
            	case 1 :
            	    // JPQL.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt25 >= 1 ) break loop25;
                        EarlyExitException eee =
                            new EarlyExitException(25, input);
                        throw eee;
                }
                cnt25++;
            } while (true);

            match('\''); 
            mTIME_STRING(); 
            match('\''); 
            // JPQL.g:1495:68: ( ' ' | '\\t' )*
            loop26:
            do {
                int alt26=2;
                int LA26_0 = input.LA(1);

                if ( (LA26_0=='\t'||LA26_0==' ') ) {
                    alt26=1;
                }


                switch (alt26) {
            	case 1 :
            	    // JPQL.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop26;
                }
            } while (true);

            mRIGHT_CURLY_BRACKET(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TIME_LITERAL"

    // $ANTLR start "TIMESTAMP_LITERAL"
    public final void mTIMESTAMP_LITERAL() throws RecognitionException {
        try {
            int _type = TIMESTAMP_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1499:5: ( LEFT_CURLY_BRACKET ( 'ts' ) ( ' ' | '\\t' )+ '\\'' DATE_STRING ' ' TIME_STRING '\\'' ( ' ' | '\\t' )* RIGHT_CURLY_BRACKET )
            // JPQL.g:1499:7: LEFT_CURLY_BRACKET ( 'ts' ) ( ' ' | '\\t' )+ '\\'' DATE_STRING ' ' TIME_STRING '\\'' ( ' ' | '\\t' )* RIGHT_CURLY_BRACKET
            {
            mLEFT_CURLY_BRACKET(); 
            // JPQL.g:1499:26: ( 'ts' )
            // JPQL.g:1499:27: 'ts'
            {
            match("ts"); 


            }

            // JPQL.g:1499:33: ( ' ' | '\\t' )+
            int cnt27=0;
            loop27:
            do {
                int alt27=2;
                int LA27_0 = input.LA(1);

                if ( (LA27_0=='\t'||LA27_0==' ') ) {
                    alt27=1;
                }


                switch (alt27) {
            	case 1 :
            	    // JPQL.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt27 >= 1 ) break loop27;
                        EarlyExitException eee =
                            new EarlyExitException(27, input);
                        throw eee;
                }
                cnt27++;
            } while (true);

            match('\''); 
            mDATE_STRING(); 
            match(' '); 
            mTIME_STRING(); 
            match('\''); 
            // JPQL.g:1499:85: ( ' ' | '\\t' )*
            loop28:
            do {
                int alt28=2;
                int LA28_0 = input.LA(1);

                if ( (LA28_0=='\t'||LA28_0==' ') ) {
                    alt28=1;
                }


                switch (alt28) {
            	case 1 :
            	    // JPQL.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop28;
                }
            } while (true);

            mRIGHT_CURLY_BRACKET(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TIMESTAMP_LITERAL"

    // $ANTLR start "DATE_STRING"
    public final void mDATE_STRING() throws RecognitionException {
        try {
            int _type = DATE_STRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1503:5: ( '0' .. '9' '0' .. '9' '0' .. '9' '0' .. '9' '-' '0' .. '9' '0' .. '9' '-' '0' .. '9' '0' .. '9' )
            // JPQL.g:1503:7: '0' .. '9' '0' .. '9' '0' .. '9' '0' .. '9' '-' '0' .. '9' '0' .. '9' '-' '0' .. '9' '0' .. '9'
            {
            matchRange('0','9'); 
            matchRange('0','9'); 
            matchRange('0','9'); 
            matchRange('0','9'); 
            match('-'); 
            matchRange('0','9'); 
            matchRange('0','9'); 
            match('-'); 
            matchRange('0','9'); 
            matchRange('0','9'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DATE_STRING"

    // $ANTLR start "TIME_STRING"
    public final void mTIME_STRING() throws RecognitionException {
        try {
            int _type = TIME_STRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1507:5: ( '0' .. '9' ( '0' .. '9' )? ':' '0' .. '9' '0' .. '9' ':' '0' .. '9' '0' .. '9' '.' ( '0' .. '9' )* )
            // JPQL.g:1507:7: '0' .. '9' ( '0' .. '9' )? ':' '0' .. '9' '0' .. '9' ':' '0' .. '9' '0' .. '9' '.' ( '0' .. '9' )*
            {
            matchRange('0','9'); 
            // JPQL.g:1507:16: ( '0' .. '9' )?
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( ((LA29_0>='0' && LA29_0<='9')) ) {
                alt29=1;
            }
            switch (alt29) {
                case 1 :
                    // JPQL.g:1507:17: '0' .. '9'
                    {
                    matchRange('0','9'); 

                    }
                    break;

            }

            match(':'); 
            matchRange('0','9'); 
            matchRange('0','9'); 
            match(':'); 
            matchRange('0','9'); 
            matchRange('0','9'); 
            match('.'); 
            // JPQL.g:1507:76: ( '0' .. '9' )*
            loop30:
            do {
                int alt30=2;
                int LA30_0 = input.LA(1);

                if ( ((LA30_0>='0' && LA30_0<='9')) ) {
                    alt30=1;
                }


                switch (alt30) {
            	case 1 :
            	    // JPQL.g:1507:76: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    break loop30;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TIME_STRING"

    // $ANTLR start "DOUBLE_SUFFIX"
    public final void mDOUBLE_SUFFIX() throws RecognitionException {
        try {
            // JPQL.g:1512:5: ( 'd' )
            // JPQL.g:1512:7: 'd'
            {
            match('d'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "DOUBLE_SUFFIX"

    // $ANTLR start "EQUALS"
    public final void mEQUALS() throws RecognitionException {
        try {
            int _type = EQUALS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1516:5: ( '=' )
            // JPQL.g:1516:7: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EQUALS"

    // $ANTLR start "GREATER_THAN"
    public final void mGREATER_THAN() throws RecognitionException {
        try {
            int _type = GREATER_THAN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1520:5: ( '>' )
            // JPQL.g:1520:7: '>'
            {
            match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GREATER_THAN"

    // $ANTLR start "GREATER_THAN_EQUAL_TO"
    public final void mGREATER_THAN_EQUAL_TO() throws RecognitionException {
        try {
            int _type = GREATER_THAN_EQUAL_TO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1524:5: ( '>=' )
            // JPQL.g:1524:7: '>='
            {
            match(">="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GREATER_THAN_EQUAL_TO"

    // $ANTLR start "LESS_THAN"
    public final void mLESS_THAN() throws RecognitionException {
        try {
            int _type = LESS_THAN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1528:5: ( '<' )
            // JPQL.g:1528:7: '<'
            {
            match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LESS_THAN"

    // $ANTLR start "LESS_THAN_EQUAL_TO"
    public final void mLESS_THAN_EQUAL_TO() throws RecognitionException {
        try {
            int _type = LESS_THAN_EQUAL_TO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1532:5: ( '<=' )
            // JPQL.g:1532:7: '<='
            {
            match("<="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LESS_THAN_EQUAL_TO"

    // $ANTLR start "NOT_EQUAL_TO"
    public final void mNOT_EQUAL_TO() throws RecognitionException {
        try {
            int _type = NOT_EQUAL_TO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1536:5: ( '<>' | '!=' )
            int alt31=2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0=='<') ) {
                alt31=1;
            }
            else if ( (LA31_0=='!') ) {
                alt31=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 31, 0, input);

                throw nvae;
            }
            switch (alt31) {
                case 1 :
                    // JPQL.g:1536:7: '<>'
                    {
                    match("<>"); 


                    }
                    break;
                case 2 :
                    // JPQL.g:1537:7: '!='
                    {
                    match("!="); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NOT_EQUAL_TO"

    // $ANTLR start "MULTIPLY"
    public final void mMULTIPLY() throws RecognitionException {
        try {
            int _type = MULTIPLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1541:5: ( '*' )
            // JPQL.g:1541:7: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MULTIPLY"

    // $ANTLR start "DIVIDE"
    public final void mDIVIDE() throws RecognitionException {
        try {
            int _type = DIVIDE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1545:5: ( '/' )
            // JPQL.g:1545:7: '/'
            {
            match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DIVIDE"

    // $ANTLR start "PLUS"
    public final void mPLUS() throws RecognitionException {
        try {
            int _type = PLUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1549:5: ( '+' )
            // JPQL.g:1549:7: '+'
            {
            match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "MINUS"
    public final void mMINUS() throws RecognitionException {
        try {
            int _type = MINUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1553:5: ( '-' )
            // JPQL.g:1553:7: '-'
            {
            match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "POSITIONAL_PARAM"
    public final void mPOSITIONAL_PARAM() throws RecognitionException {
        try {
            int _type = POSITIONAL_PARAM;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1558:5: ( '?' ( '1' .. '9' ) ( '0' .. '9' )* )
            // JPQL.g:1558:7: '?' ( '1' .. '9' ) ( '0' .. '9' )*
            {
            match('?'); 
            // JPQL.g:1558:11: ( '1' .. '9' )
            // JPQL.g:1558:12: '1' .. '9'
            {
            matchRange('1','9'); 

            }

            // JPQL.g:1558:22: ( '0' .. '9' )*
            loop32:
            do {
                int alt32=2;
                int LA32_0 = input.LA(1);

                if ( ((LA32_0>='0' && LA32_0<='9')) ) {
                    alt32=1;
                }


                switch (alt32) {
            	case 1 :
            	    // JPQL.g:1558:23: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    break loop32;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "POSITIONAL_PARAM"

    // $ANTLR start "NAMED_PARAM"
    public final void mNAMED_PARAM() throws RecognitionException {
        try {
            int _type = NAMED_PARAM;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1562:5: ( ':' TEXTCHAR )
            // JPQL.g:1562:7: ':' TEXTCHAR
            {
            match(':'); 
            mTEXTCHAR(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NAMED_PARAM"

    // $ANTLR start "STRING_LITERAL_DOUBLE_QUOTED"
    public final void mSTRING_LITERAL_DOUBLE_QUOTED() throws RecognitionException {
        try {
            int _type = STRING_LITERAL_DOUBLE_QUOTED;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1568:5: ( '\"' (~ ( '\"' ) )* '\"' )
            // JPQL.g:1568:7: '\"' (~ ( '\"' ) )* '\"'
            {
            match('\"'); 
            // JPQL.g:1568:11: (~ ( '\"' ) )*
            loop33:
            do {
                int alt33=2;
                int LA33_0 = input.LA(1);

                if ( ((LA33_0>='\u0000' && LA33_0<='!')||(LA33_0>='#' && LA33_0<='\uFFFF')) ) {
                    alt33=1;
                }


                switch (alt33) {
            	case 1 :
            	    // JPQL.g:1568:12: ~ ( '\"' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop33;
                }
            } while (true);

            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "STRING_LITERAL_DOUBLE_QUOTED"

    // $ANTLR start "STRING_LITERAL_SINGLE_QUOTED"
    public final void mSTRING_LITERAL_SINGLE_QUOTED() throws RecognitionException {
        try {
            int _type = STRING_LITERAL_SINGLE_QUOTED;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // JPQL.g:1572:5: ( '\\'' (~ ( '\\'' ) | ( '\\'\\'' ) )* '\\'' )
            // JPQL.g:1572:7: '\\'' (~ ( '\\'' ) | ( '\\'\\'' ) )* '\\''
            {
            match('\''); 
            // JPQL.g:1572:12: (~ ( '\\'' ) | ( '\\'\\'' ) )*
            loop34:
            do {
                int alt34=3;
                int LA34_0 = input.LA(1);

                if ( (LA34_0=='\'') ) {
                    int LA34_1 = input.LA(2);

                    if ( (LA34_1=='\'') ) {
                        alt34=2;
                    }


                }
                else if ( ((LA34_0>='\u0000' && LA34_0<='&')||(LA34_0>='(' && LA34_0<='\uFFFF')) ) {
                    alt34=1;
                }


                switch (alt34) {
            	case 1 :
            	    // JPQL.g:1572:13: ~ ( '\\'' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;
            	case 2 :
            	    // JPQL.g:1572:24: ( '\\'\\'' )
            	    {
            	    // JPQL.g:1572:24: ( '\\'\\'' )
            	    // JPQL.g:1572:25: '\\'\\''
            	    {
            	    match("''"); 


            	    }


            	    }
            	    break;

            	default :
            	    break loop34;
                }
            } while (true);

            match('\''); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "STRING_LITERAL_SINGLE_QUOTED"

    public void mTokens() throws RecognitionException {
        // JPQL.g:1:8: ( ABS | ALL | AND | ANY | AS | ASC | AVG | BETWEEN | BOTH | BY | CASE | COALESCE | CONCAT | COUNT | CURRENT_DATE | CURRENT_TIME | CURRENT_TIMESTAMP | DESC | DELETE | DISTINCT | ELSE | EMPTY | END | ENTRY | ESCAPE | EXISTS | FALSE | FETCH | FUNC | FROM | GROUP | HAVING | IN | INDEX | INNER | IS | JOIN | KEY | LEADING | LEFT | LENGTH | LIKE | LOCATE | LOWER | MAX | MEMBER | MIN | MOD | NEW | NOT | NULL | NULLIF | OBJECT | OF | OR | ORDER | OUTER | SELECT | SET | SIZE | SQRT | SOME | SUBSTRING | SUM | THEN | TRAILING | TREAT | TRIM | TRUE | TYPE | UNKNOWN | UPDATE | UPPER | VALUE | WHEN | WHERE | DOT | WS | LEFT_ROUND_BRACKET | LEFT_CURLY_BRACKET | RIGHT_ROUND_BRACKET | RIGHT_CURLY_BRACKET | COMMA | IDENT | HEX_LITERAL | INTEGER_LITERAL | LONG_LITERAL | OCTAL_LITERAL | DOUBLE_LITERAL | FLOAT_LITERAL | DATE_LITERAL | TIME_LITERAL | TIMESTAMP_LITERAL | DATE_STRING | TIME_STRING | EQUALS | GREATER_THAN | GREATER_THAN_EQUAL_TO | LESS_THAN | LESS_THAN_EQUAL_TO | NOT_EQUAL_TO | MULTIPLY | DIVIDE | PLUS | MINUS | POSITIONAL_PARAM | NAMED_PARAM | STRING_LITERAL_DOUBLE_QUOTED | STRING_LITERAL_SINGLE_QUOTED )
        int alt35=109;
        alt35 = dfa35.predict(input);
        switch (alt35) {
            case 1 :
                // JPQL.g:1:10: ABS
                {
                mABS(); 

                }
                break;
            case 2 :
                // JPQL.g:1:14: ALL
                {
                mALL(); 

                }
                break;
            case 3 :
                // JPQL.g:1:18: AND
                {
                mAND(); 

                }
                break;
            case 4 :
                // JPQL.g:1:22: ANY
                {
                mANY(); 

                }
                break;
            case 5 :
                // JPQL.g:1:26: AS
                {
                mAS(); 

                }
                break;
            case 6 :
                // JPQL.g:1:29: ASC
                {
                mASC(); 

                }
                break;
            case 7 :
                // JPQL.g:1:33: AVG
                {
                mAVG(); 

                }
                break;
            case 8 :
                // JPQL.g:1:37: BETWEEN
                {
                mBETWEEN(); 

                }
                break;
            case 9 :
                // JPQL.g:1:45: BOTH
                {
                mBOTH(); 

                }
                break;
            case 10 :
                // JPQL.g:1:50: BY
                {
                mBY(); 

                }
                break;
            case 11 :
                // JPQL.g:1:53: CASE
                {
                mCASE(); 

                }
                break;
            case 12 :
                // JPQL.g:1:58: COALESCE
                {
                mCOALESCE(); 

                }
                break;
            case 13 :
                // JPQL.g:1:67: CONCAT
                {
                mCONCAT(); 

                }
                break;
            case 14 :
                // JPQL.g:1:74: COUNT
                {
                mCOUNT(); 

                }
                break;
            case 15 :
                // JPQL.g:1:80: CURRENT_DATE
                {
                mCURRENT_DATE(); 

                }
                break;
            case 16 :
                // JPQL.g:1:93: CURRENT_TIME
                {
                mCURRENT_TIME(); 

                }
                break;
            case 17 :
                // JPQL.g:1:106: CURRENT_TIMESTAMP
                {
                mCURRENT_TIMESTAMP(); 

                }
                break;
            case 18 :
                // JPQL.g:1:124: DESC
                {
                mDESC(); 

                }
                break;
            case 19 :
                // JPQL.g:1:129: DELETE
                {
                mDELETE(); 

                }
                break;
            case 20 :
                // JPQL.g:1:136: DISTINCT
                {
                mDISTINCT(); 

                }
                break;
            case 21 :
                // JPQL.g:1:145: ELSE
                {
                mELSE(); 

                }
                break;
            case 22 :
                // JPQL.g:1:150: EMPTY
                {
                mEMPTY(); 

                }
                break;
            case 23 :
                // JPQL.g:1:156: END
                {
                mEND(); 

                }
                break;
            case 24 :
                // JPQL.g:1:160: ENTRY
                {
                mENTRY(); 

                }
                break;
            case 25 :
                // JPQL.g:1:166: ESCAPE
                {
                mESCAPE(); 

                }
                break;
            case 26 :
                // JPQL.g:1:173: EXISTS
                {
                mEXISTS(); 

                }
                break;
            case 27 :
                // JPQL.g:1:180: FALSE
                {
                mFALSE(); 

                }
                break;
            case 28 :
                // JPQL.g:1:186: FETCH
                {
                mFETCH(); 

                }
                break;
            case 29 :
                // JPQL.g:1:192: FUNC
                {
                mFUNC(); 

                }
                break;
            case 30 :
                // JPQL.g:1:197: FROM
                {
                mFROM(); 

                }
                break;
            case 31 :
                // JPQL.g:1:202: GROUP
                {
                mGROUP(); 

                }
                break;
            case 32 :
                // JPQL.g:1:208: HAVING
                {
                mHAVING(); 

                }
                break;
            case 33 :
                // JPQL.g:1:215: IN
                {
                mIN(); 

                }
                break;
            case 34 :
                // JPQL.g:1:218: INDEX
                {
                mINDEX(); 

                }
                break;
            case 35 :
                // JPQL.g:1:224: INNER
                {
                mINNER(); 

                }
                break;
            case 36 :
                // JPQL.g:1:230: IS
                {
                mIS(); 

                }
                break;
            case 37 :
                // JPQL.g:1:233: JOIN
                {
                mJOIN(); 

                }
                break;
            case 38 :
                // JPQL.g:1:238: KEY
                {
                mKEY(); 

                }
                break;
            case 39 :
                // JPQL.g:1:242: LEADING
                {
                mLEADING(); 

                }
                break;
            case 40 :
                // JPQL.g:1:250: LEFT
                {
                mLEFT(); 

                }
                break;
            case 41 :
                // JPQL.g:1:255: LENGTH
                {
                mLENGTH(); 

                }
                break;
            case 42 :
                // JPQL.g:1:262: LIKE
                {
                mLIKE(); 

                }
                break;
            case 43 :
                // JPQL.g:1:267: LOCATE
                {
                mLOCATE(); 

                }
                break;
            case 44 :
                // JPQL.g:1:274: LOWER
                {
                mLOWER(); 

                }
                break;
            case 45 :
                // JPQL.g:1:280: MAX
                {
                mMAX(); 

                }
                break;
            case 46 :
                // JPQL.g:1:284: MEMBER
                {
                mMEMBER(); 

                }
                break;
            case 47 :
                // JPQL.g:1:291: MIN
                {
                mMIN(); 

                }
                break;
            case 48 :
                // JPQL.g:1:295: MOD
                {
                mMOD(); 

                }
                break;
            case 49 :
                // JPQL.g:1:299: NEW
                {
                mNEW(); 

                }
                break;
            case 50 :
                // JPQL.g:1:303: NOT
                {
                mNOT(); 

                }
                break;
            case 51 :
                // JPQL.g:1:307: NULL
                {
                mNULL(); 

                }
                break;
            case 52 :
                // JPQL.g:1:312: NULLIF
                {
                mNULLIF(); 

                }
                break;
            case 53 :
                // JPQL.g:1:319: OBJECT
                {
                mOBJECT(); 

                }
                break;
            case 54 :
                // JPQL.g:1:326: OF
                {
                mOF(); 

                }
                break;
            case 55 :
                // JPQL.g:1:329: OR
                {
                mOR(); 

                }
                break;
            case 56 :
                // JPQL.g:1:332: ORDER
                {
                mORDER(); 

                }
                break;
            case 57 :
                // JPQL.g:1:338: OUTER
                {
                mOUTER(); 

                }
                break;
            case 58 :
                // JPQL.g:1:344: SELECT
                {
                mSELECT(); 

                }
                break;
            case 59 :
                // JPQL.g:1:351: SET
                {
                mSET(); 

                }
                break;
            case 60 :
                // JPQL.g:1:355: SIZE
                {
                mSIZE(); 

                }
                break;
            case 61 :
                // JPQL.g:1:360: SQRT
                {
                mSQRT(); 

                }
                break;
            case 62 :
                // JPQL.g:1:365: SOME
                {
                mSOME(); 

                }
                break;
            case 63 :
                // JPQL.g:1:370: SUBSTRING
                {
                mSUBSTRING(); 

                }
                break;
            case 64 :
                // JPQL.g:1:380: SUM
                {
                mSUM(); 

                }
                break;
            case 65 :
                // JPQL.g:1:384: THEN
                {
                mTHEN(); 

                }
                break;
            case 66 :
                // JPQL.g:1:389: TRAILING
                {
                mTRAILING(); 

                }
                break;
            case 67 :
                // JPQL.g:1:398: TREAT
                {
                mTREAT(); 

                }
                break;
            case 68 :
                // JPQL.g:1:404: TRIM
                {
                mTRIM(); 

                }
                break;
            case 69 :
                // JPQL.g:1:409: TRUE
                {
                mTRUE(); 

                }
                break;
            case 70 :
                // JPQL.g:1:414: TYPE
                {
                mTYPE(); 

                }
                break;
            case 71 :
                // JPQL.g:1:419: UNKNOWN
                {
                mUNKNOWN(); 

                }
                break;
            case 72 :
                // JPQL.g:1:427: UPDATE
                {
                mUPDATE(); 

                }
                break;
            case 73 :
                // JPQL.g:1:434: UPPER
                {
                mUPPER(); 

                }
                break;
            case 74 :
                // JPQL.g:1:440: VALUE
                {
                mVALUE(); 

                }
                break;
            case 75 :
                // JPQL.g:1:446: WHEN
                {
                mWHEN(); 

                }
                break;
            case 76 :
                // JPQL.g:1:451: WHERE
                {
                mWHERE(); 

                }
                break;
            case 77 :
                // JPQL.g:1:457: DOT
                {
                mDOT(); 

                }
                break;
            case 78 :
                // JPQL.g:1:461: WS
                {
                mWS(); 

                }
                break;
            case 79 :
                // JPQL.g:1:464: LEFT_ROUND_BRACKET
                {
                mLEFT_ROUND_BRACKET(); 

                }
                break;
            case 80 :
                // JPQL.g:1:483: LEFT_CURLY_BRACKET
                {
                mLEFT_CURLY_BRACKET(); 

                }
                break;
            case 81 :
                // JPQL.g:1:502: RIGHT_ROUND_BRACKET
                {
                mRIGHT_ROUND_BRACKET(); 

                }
                break;
            case 82 :
                // JPQL.g:1:522: RIGHT_CURLY_BRACKET
                {
                mRIGHT_CURLY_BRACKET(); 

                }
                break;
            case 83 :
                // JPQL.g:1:542: COMMA
                {
                mCOMMA(); 

                }
                break;
            case 84 :
                // JPQL.g:1:548: IDENT
                {
                mIDENT(); 

                }
                break;
            case 85 :
                // JPQL.g:1:554: HEX_LITERAL
                {
                mHEX_LITERAL(); 

                }
                break;
            case 86 :
                // JPQL.g:1:566: INTEGER_LITERAL
                {
                mINTEGER_LITERAL(); 

                }
                break;
            case 87 :
                // JPQL.g:1:582: LONG_LITERAL
                {
                mLONG_LITERAL(); 

                }
                break;
            case 88 :
                // JPQL.g:1:595: OCTAL_LITERAL
                {
                mOCTAL_LITERAL(); 

                }
                break;
            case 89 :
                // JPQL.g:1:609: DOUBLE_LITERAL
                {
                mDOUBLE_LITERAL(); 

                }
                break;
            case 90 :
                // JPQL.g:1:624: FLOAT_LITERAL
                {
                mFLOAT_LITERAL(); 

                }
                break;
            case 91 :
                // JPQL.g:1:638: DATE_LITERAL
                {
                mDATE_LITERAL(); 

                }
                break;
            case 92 :
                // JPQL.g:1:651: TIME_LITERAL
                {
                mTIME_LITERAL(); 

                }
                break;
            case 93 :
                // JPQL.g:1:664: TIMESTAMP_LITERAL
                {
                mTIMESTAMP_LITERAL(); 

                }
                break;
            case 94 :
                // JPQL.g:1:682: DATE_STRING
                {
                mDATE_STRING(); 

                }
                break;
            case 95 :
                // JPQL.g:1:694: TIME_STRING
                {
                mTIME_STRING(); 

                }
                break;
            case 96 :
                // JPQL.g:1:706: EQUALS
                {
                mEQUALS(); 

                }
                break;
            case 97 :
                // JPQL.g:1:713: GREATER_THAN
                {
                mGREATER_THAN(); 

                }
                break;
            case 98 :
                // JPQL.g:1:726: GREATER_THAN_EQUAL_TO
                {
                mGREATER_THAN_EQUAL_TO(); 

                }
                break;
            case 99 :
                // JPQL.g:1:748: LESS_THAN
                {
                mLESS_THAN(); 

                }
                break;
            case 100 :
                // JPQL.g:1:758: LESS_THAN_EQUAL_TO
                {
                mLESS_THAN_EQUAL_TO(); 

                }
                break;
            case 101 :
                // JPQL.g:1:777: NOT_EQUAL_TO
                {
                mNOT_EQUAL_TO(); 

                }
                break;
            case 102 :
                // JPQL.g:1:790: MULTIPLY
                {
                mMULTIPLY(); 

                }
                break;
            case 103 :
                // JPQL.g:1:799: DIVIDE
                {
                mDIVIDE(); 

                }
                break;
            case 104 :
                // JPQL.g:1:806: PLUS
                {
                mPLUS(); 

                }
                break;
            case 105 :
                // JPQL.g:1:811: MINUS
                {
                mMINUS(); 

                }
                break;
            case 106 :
                // JPQL.g:1:817: POSITIONAL_PARAM
                {
                mPOSITIONAL_PARAM(); 

                }
                break;
            case 107 :
                // JPQL.g:1:834: NAMED_PARAM
                {
                mNAMED_PARAM(); 

                }
                break;
            case 108 :
                // JPQL.g:1:846: STRING_LITERAL_DOUBLE_QUOTED
                {
                mSTRING_LITERAL_DOUBLE_QUOTED(); 

                }
                break;
            case 109 :
                // JPQL.g:1:875: STRING_LITERAL_SINGLE_QUOTED
                {
                mSTRING_LITERAL_SINGLE_QUOTED(); 

                }
                break;

        }

    }


    protected DFA17 dfa17 = new DFA17(this);
    protected DFA20 dfa20 = new DFA20(this);
    protected DFA35 dfa35 = new DFA35(this);
    static final String DFA17_eotS =
        "\2\uffff\1\5\3\uffff";
    static final String DFA17_eofS =
        "\6\uffff";
    static final String DFA17_minS =
        "\1\55\2\56\3\uffff";
    static final String DFA17_maxS =
        "\3\71\3\uffff";
    static final String DFA17_acceptS =
        "\3\uffff\1\2\1\1\1\3";
    static final String DFA17_specialS =
        "\6\uffff}>";
    static final String[] DFA17_transitionS = {
            "\1\1\1\3\1\uffff\12\2",
            "\1\3\1\uffff\12\2",
            "\1\4\1\uffff\12\2",
            "",
            "",
            ""
    };

    static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
    static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
    static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);
    static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);
    static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
    static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);
    static final short[][] DFA17_transition;

    static {
        int numStates = DFA17_transitionS.length;
        DFA17_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
        }
    }

    // Made static for performance reasons.
    static class DFA17 extends DFA {

        public DFA17(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 17;
            this.eot = DFA17_eot;
            this.eof = DFA17_eof;
            this.min = DFA17_min;
            this.max = DFA17_max;
            this.accept = DFA17_accept;
            this.special = DFA17_special;
            this.transition = DFA17_transition;
        }
        public String getDescription() {
            return "1462:1: fragment NUMERIC_DIGITS : ( ( MINUS )? ( '0' .. '9' )+ '.' ( '0' .. '9' )* | ( MINUS )? '.' ( '0' .. '9' )+ | ( MINUS )? ( '0' .. '9' )+ );";
        }
    }
    static final String DFA20_eotS =
        "\11\uffff";
    static final String DFA20_eofS =
        "\11\uffff";
    static final String DFA20_minS =
        "\1\55\2\56\2\60\2\uffff\2\60";
    static final String DFA20_maxS =
        "\2\71\1\146\1\71\1\146\2\uffff\2\146";
    static final String DFA20_acceptS =
        "\5\uffff\1\2\1\1\2\uffff";
    static final String DFA20_specialS =
        "\11\uffff}>";
    static final String[] DFA20_transitionS = {
            "\1\1\1\3\1\uffff\12\2",
            "\1\3\1\uffff\12\2",
            "\1\4\1\uffff\12\2\13\uffff\1\6\37\uffff\1\6\1\5",
            "\12\7",
            "\12\10\13\uffff\1\6\37\uffff\1\6\1\5",
            "",
            "",
            "\12\7\13\uffff\1\6\37\uffff\1\6\1\5",
            "\12\10\13\uffff\1\6\37\uffff\1\6\1\5"
    };

    static final short[] DFA20_eot = DFA.unpackEncodedString(DFA20_eotS);
    static final short[] DFA20_eof = DFA.unpackEncodedString(DFA20_eofS);
    static final char[] DFA20_min = DFA.unpackEncodedStringToUnsignedChars(DFA20_minS);
    static final char[] DFA20_max = DFA.unpackEncodedStringToUnsignedChars(DFA20_maxS);
    static final short[] DFA20_accept = DFA.unpackEncodedString(DFA20_acceptS);
    static final short[] DFA20_special = DFA.unpackEncodedString(DFA20_specialS);
    static final short[][] DFA20_transition;

    static {
        int numStates = DFA20_transitionS.length;
        DFA20_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA20_transition[i] = DFA.unpackEncodedString(DFA20_transitionS[i]);
        }
    }

    // Made static for performance reasons.
    static class DFA20 extends DFA {

        public DFA20(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 20;
            this.eot = DFA20_eot;
            this.eof = DFA20_eof;
            this.min = DFA20_min;
            this.max = DFA20_max;
            this.accept = DFA20_accept;
            this.special = DFA20_special;
            this.transition = DFA20_transition;
        }
        public String getDescription() {
            return "1473:1: FLOAT_LITERAL : ( NUMERIC_DIGITS EXPONENT ( FLOAT_SUFFIX )? | NUMERIC_DIGITS FLOAT_SUFFIX );";
        }
    }
    static final String DFA35_eotS =
        "\1\uffff\24\34\1\142\2\uffff\1\143\4\uffff\1\151\1\157\1\151\1"+
        "\uffff\1\165\1\167\10\uffff\3\34\1\175\3\34\1\u0081\20\34\1\u0098"+
        "\1\u0099\15\34\1\u00aa\1\u00ac\15\34\1\156\5\uffff\1\u00c3\1\156"+
        "\2\uffff\1\156\5\uffff\3\151\4\uffff\1\u00ca\1\u00cb\1\u00cc\1\u00cd"+
        "\1\u00ce\1\uffff\1\u00cf\2\34\1\uffff\12\34\1\u00dc\13\34\2\uffff"+
        "\1\34\1\u00e9\6\34\1\u00f0\1\34\1\u00f2\1\u00f3\1\u00f4\1\u00f5"+
        "\2\34\1\uffff\1\34\1\uffff\2\34\1\u00fb\4\34\1\u0100\13\34\2\uffff"+
        "\1\u00c3\1\uffff\2\156\1\u00c3\1\156\2\151\6\uffff\1\34\1\u0111"+
        "\1\u0112\4\34\1\u0117\2\34\1\u011a\1\34\1\uffff\5\34\1\u0121\1\u0122"+
        "\4\34\1\u0127\1\uffff\1\34\1\u0129\1\34\1\u012b\2\34\1\uffff\1\34"+
        "\4\uffff\1\u0130\4\34\1\uffff\1\u0135\1\u0136\1\u0137\1\34\1\uffff"+
        "\1\u0139\2\34\1\u013c\1\u013d\1\u013e\4\34\1\u0143\1\34\1\u00c3"+
        "\1\156\1\151\1\34\2\uffff\2\34\1\u0149\1\34\1\uffff\2\34\1\uffff"+
        "\1\u014d\1\u014e\2\34\1\u0151\1\u0152\2\uffff\1\u0153\1\34\1\u0155"+
        "\1\u0156\1\uffff\1\34\1\uffff\1\34\1\uffff\1\34\1\u015a\2\34\1\uffff"+
        "\1\34\1\u015e\1\u015f\1\34\3\uffff\1\34\1\uffff\1\34\1\u0163\3\uffff"+
        "\2\34\1\u0166\1\u0167\1\uffff\1\u0168\1\uffff\2\34\1\u016b\1\uffff"+
        "\1\34\1\u016d\1\34\2\uffff\1\u016f\1\u0170\3\uffff\1\u0171\2\uffff"+
        "\1\34\1\u0173\1\u0174\1\uffff\1\u0175\1\u0176\1\u0177\2\uffff\1"+
        "\u0178\2\34\1\uffff\1\34\1\u017c\3\uffff\1\u017d\1\34\1\uffff\1"+
        "\34\1\uffff\1\34\3\uffff\1\u0181\6\uffff\2\34\1\u0184\2\uffff\1"+
        "\u0185\1\34\1\u0188\1\uffff\1\34\1\u018a\2\uffff\2\34\1\uffff\1"+
        "\u018d\1\uffff\2\34\1\uffff\2\34\1\u0192\1\u0194\1\uffff\1\34\1"+
        "\uffff\3\34\1\u0199\1\uffff";
    static final String DFA35_eofS =
        "\u019a\uffff";
    static final String DFA35_minS =
        "\1\11\1\142\1\145\1\141\1\145\1\154\1\141\1\162\1\141\1\156\1\157"+
        "\2\145\1\141\1\145\1\142\1\145\1\150\1\156\1\141\1\150\1\60\2\uffff"+
        "\1\144\4\uffff\3\56\1\uffff\2\75\10\uffff\1\163\1\154\1\144\1\44"+
        "\1\147\2\164\1\44\1\163\1\141\1\162\1\154\2\163\1\160\1\144\1\143"+
        "\1\151\1\154\1\164\1\156\2\157\1\166\2\44\1\151\1\171\1\141\1\153"+
        "\1\143\1\170\1\155\1\156\1\144\1\167\1\164\1\154\1\152\2\44\1\164"+
        "\1\154\1\172\1\162\1\155\1\142\1\145\1\141\1\160\1\153\1\144\1\154"+
        "\1\145\1\60\2\uffff\1\11\2\uffff\2\56\2\uffff\1\60\4\uffff\1\60"+
        "\3\56\4\uffff\5\44\1\uffff\1\44\1\167\1\150\1\uffff\1\145\1\154"+
        "\1\143\1\156\1\162\1\143\1\145\1\164\1\145\1\164\1\44\1\162\1\141"+
        "\2\163\2\143\1\155\1\165\1\151\2\145\2\uffff\1\156\1\44\1\144\1"+
        "\164\1\147\1\145\1\141\1\145\1\44\1\142\4\44\1\154\1\145\1\uffff"+
        "\1\145\1\uffff\2\145\1\44\1\145\1\164\1\145\1\163\1\44\1\156\1\151"+
        "\1\141\1\155\2\145\1\156\1\141\1\145\1\165\1\156\2\uffff\1\56\1"+
        "\uffff\1\56\1\60\4\56\6\uffff\1\145\2\44\1\145\1\141\1\164\1\145"+
        "\1\44\1\164\1\151\1\44\1\171\1\uffff\1\171\1\160\1\164\1\145\1\150"+
        "\2\44\1\160\1\156\1\170\1\162\1\44\1\uffff\1\151\1\44\1\164\1\44"+
        "\1\164\1\162\1\uffff\1\145\4\uffff\1\44\1\143\2\162\1\143\1\uffff"+
        "\3\44\1\164\1\uffff\1\44\1\154\1\164\3\44\1\157\1\164\1\162\1\145"+
        "\1\44\1\145\3\55\1\145\2\uffff\1\163\1\164\1\44\1\156\1\uffff\1"+
        "\145\1\156\1\uffff\2\44\1\145\1\163\2\44\2\uffff\1\44\1\147\2\44"+
        "\1\uffff\1\156\1\uffff\1\150\1\uffff\1\145\1\44\1\162\1\146\1\uffff"+
        "\1\164\2\44\1\164\3\uffff\1\162\1\uffff\1\151\1\44\3\uffff\1\167"+
        "\1\145\2\44\1\uffff\1\44\1\uffff\1\156\1\143\1\44\1\uffff\1\164"+
        "\1\44\1\143\2\uffff\2\44\3\uffff\1\44\2\uffff\1\147\2\44\1\uffff"+
        "\3\44\2\uffff\1\44\1\151\1\156\1\uffff\1\156\1\44\3\uffff\1\44\1"+
        "\145\1\uffff\1\137\1\uffff\1\164\3\uffff\1\44\6\uffff\1\156\1\147"+
        "\1\44\2\uffff\1\44\1\144\1\44\1\uffff\1\147\1\44\2\uffff\1\141\1"+
        "\151\1\uffff\1\44\1\uffff\1\164\1\155\1\uffff\2\145\2\44\1\uffff"+
        "\1\164\1\uffff\1\141\1\155\1\160\1\44\1\uffff";
    static final String DFA35_maxS =
        "\1\176\1\166\1\171\1\165\1\151\1\170\1\165\1\162\1\141\1\163\1"+
        "\157\1\145\2\157\3\165\1\171\1\160\1\141\1\150\1\71\2\uffff\1\164"+
        "\4\uffff\1\170\1\71\1\154\1\uffff\1\75\1\76\10\uffff\1\163\1\154"+
        "\1\171\1\ufffe\1\147\2\164\1\ufffe\1\163\1\165\1\162\3\163\1\160"+
        "\1\164\1\143\1\151\1\154\1\164\1\156\2\157\1\166\2\ufffe\1\151\1"+
        "\171\1\156\1\153\1\167\1\170\1\155\1\156\1\144\1\167\1\164\1\154"+
        "\1\152\2\ufffe\2\164\1\172\1\162\2\155\1\145\1\165\1\160\1\153\1"+
        "\160\1\154\1\145\1\146\2\uffff\1\163\2\uffff\2\146\2\uffff\1\146"+
        "\4\uffff\1\71\3\154\4\uffff\5\ufffe\1\uffff\1\ufffe\1\167\1\150"+
        "\1\uffff\1\145\1\154\1\143\1\156\1\162\1\143\1\145\1\164\1\145\1"+
        "\164\1\ufffe\1\162\1\141\2\163\2\143\1\155\1\165\1\151\2\145\2\uffff"+
        "\1\156\1\ufffe\1\144\1\164\1\147\1\145\1\141\1\145\1\ufffe\1\142"+
        "\4\ufffe\1\154\1\145\1\uffff\1\145\1\uffff\2\145\1\ufffe\1\145\1"+
        "\164\1\145\1\163\1\ufffe\1\156\1\151\1\141\1\155\2\145\1\156\1\141"+
        "\1\145\1\165\1\162\2\uffff\1\146\1\uffff\4\146\2\154\6\uffff\1\145"+
        "\2\ufffe\1\145\1\141\1\164\1\145\1\ufffe\1\164\1\151\1\ufffe\1\171"+
        "\1\uffff\1\171\1\160\1\164\1\145\1\150\2\ufffe\1\160\1\156\1\170"+
        "\1\162\1\ufffe\1\uffff\1\151\1\ufffe\1\164\1\ufffe\1\164\1\162\1"+
        "\uffff\1\145\4\uffff\1\ufffe\1\143\2\162\1\143\1\uffff\3\ufffe\1"+
        "\164\1\uffff\1\ufffe\1\154\1\164\3\ufffe\1\157\1\164\1\162\1\145"+
        "\1\ufffe\1\145\2\146\1\154\1\145\2\uffff\1\163\1\164\1\ufffe\1\156"+
        "\1\uffff\1\145\1\156\1\uffff\2\ufffe\1\145\1\163\2\ufffe\2\uffff"+
        "\1\ufffe\1\147\2\ufffe\1\uffff\1\156\1\uffff\1\150\1\uffff\1\145"+
        "\1\ufffe\1\162\1\146\1\uffff\1\164\2\ufffe\1\164\3\uffff\1\162\1"+
        "\uffff\1\151\1\ufffe\3\uffff\1\167\1\145\2\ufffe\1\uffff\1\ufffe"+
        "\1\uffff\1\156\1\143\1\ufffe\1\uffff\1\164\1\ufffe\1\143\2\uffff"+
        "\2\ufffe\3\uffff\1\ufffe\2\uffff\1\147\2\ufffe\1\uffff\3\ufffe\2"+
        "\uffff\1\ufffe\1\151\1\156\1\uffff\1\156\1\ufffe\3\uffff\1\ufffe"+
        "\1\145\1\uffff\1\137\1\uffff\1\164\3\uffff\1\ufffe\6\uffff\1\156"+
        "\1\147\1\ufffe\2\uffff\1\ufffe\1\164\1\ufffe\1\uffff\1\147\1\ufffe"+
        "\2\uffff\1\141\1\151\1\uffff\1\ufffe\1\uffff\1\164\1\155\1\uffff"+
        "\2\145\2\ufffe\1\uffff\1\164\1\uffff\1\141\1\155\1\160\1\ufffe\1"+
        "\uffff";
    static final String DFA35_acceptS =
        "\26\uffff\1\116\1\117\1\uffff\1\121\1\122\1\123\1\124\3\uffff\1"+
        "\140\2\uffff\1\145\1\146\1\147\1\150\1\152\1\153\1\154\1\155\67"+
        "\uffff\1\115\1\120\1\uffff\1\133\1\125\2\uffff\1\126\1\127\1\uffff"+
        "\1\137\1\132\1\131\1\151\4\uffff\1\142\1\141\1\144\1\143\5\uffff"+
        "\1\5\3\uffff\1\12\26\uffff\1\41\1\44\20\uffff\1\66\1\uffff\1\67"+
        "\23\uffff\1\135\1\134\1\uffff\1\130\6\uffff\1\1\1\2\1\3\1\4\1\6"+
        "\1\7\14\uffff\1\27\14\uffff\1\46\6\uffff\1\55\1\uffff\1\57\1\60"+
        "\1\61\1\62\5\uffff\1\73\4\uffff\1\100\20\uffff\1\11\1\13\4\uffff"+
        "\1\22\2\uffff\1\25\6\uffff\1\35\1\36\4\uffff\1\45\1\uffff\1\50\1"+
        "\uffff\1\52\4\uffff\1\63\4\uffff\1\74\1\75\1\76\1\uffff\1\101\2"+
        "\uffff\1\104\1\105\1\106\4\uffff\1\113\1\uffff\1\136\3\uffff\1\16"+
        "\3\uffff\1\26\1\30\2\uffff\1\33\1\34\1\37\1\uffff\1\42\1\43\3\uffff"+
        "\1\54\3\uffff\1\70\1\71\3\uffff\1\103\2\uffff\1\111\1\112\1\114"+
        "\2\uffff\1\15\1\uffff\1\23\1\uffff\1\31\1\32\1\40\1\uffff\1\51\1"+
        "\53\1\56\1\64\1\65\1\72\3\uffff\1\110\1\10\3\uffff\1\47\2\uffff"+
        "\1\107\1\14\2\uffff\1\24\1\uffff\1\102\2\uffff\1\77\4\uffff\1\17"+
        "\1\uffff\1\20\4\uffff\1\21";
    static final String DFA35_specialS =
        "\u019a\uffff}>";
    static final String[] DFA35_transitionS = {
            "\2\26\2\uffff\1\26\22\uffff\1\26\1\43\1\51\4\34\1\52\1\27\1"+
            "\31\1\44\1\46\1\33\1\36\1\25\1\45\1\35\11\37\1\50\1\34\1\42"+
            "\1\40\1\41\1\47\34\34\1\uffff\4\34\1\1\1\2\1\3\1\4\1\5\1\6\1"+
            "\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\3\34\1\20\1\21\1"+
            "\22\1\23\1\24\3\34\1\30\1\34\1\32\1\34",
            "\1\53\11\uffff\1\54\1\uffff\1\55\4\uffff\1\56\2\uffff\1\57",
            "\1\60\11\uffff\1\61\11\uffff\1\62",
            "\1\63\15\uffff\1\64\5\uffff\1\65",
            "\1\66\3\uffff\1\67",
            "\1\70\1\71\1\72\4\uffff\1\73\4\uffff\1\74",
            "\1\75\3\uffff\1\76\14\uffff\1\100\2\uffff\1\77",
            "\1\101",
            "\1\102",
            "\1\103\4\uffff\1\104",
            "\1\105",
            "\1\106",
            "\1\107\3\uffff\1\110\5\uffff\1\111",
            "\1\112\3\uffff\1\113\3\uffff\1\114\5\uffff\1\115",
            "\1\116\11\uffff\1\117\5\uffff\1\120",
            "\1\121\3\uffff\1\122\13\uffff\1\123\2\uffff\1\124",
            "\1\125\3\uffff\1\126\5\uffff\1\130\1\uffff\1\127\3\uffff\1"+
            "\131",
            "\1\132\11\uffff\1\133\6\uffff\1\134",
            "\1\135\1\uffff\1\136",
            "\1\137",
            "\1\140",
            "\12\141",
            "",
            "",
            "\1\145\17\uffff\1\144",
            "",
            "",
            "",
            "",
            "\1\153\1\uffff\10\147\2\150\1\154\12\uffff\1\155\6\uffff\1"+
            "\152\13\uffff\1\146\13\uffff\1\156\2\155\5\uffff\1\152\13\uffff"+
            "\1\146",
            "\1\160\1\uffff\1\161\11\162",
            "\1\153\1\uffff\12\163\1\154\12\uffff\1\155\6\uffff\1\152\27"+
            "\uffff\1\156\2\155\5\uffff\1\152",
            "",
            "\1\164",
            "\1\166\1\43",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\170",
            "\1\171",
            "\1\172\24\uffff\1\173",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\2\34\1\174\27\34"+
            "\5\uffff\uff7f\34",
            "\1\176",
            "\1\177",
            "\1\u0080",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0082",
            "\1\u0083\14\uffff\1\u0084\6\uffff\1\u0085",
            "\1\u0086",
            "\1\u0088\6\uffff\1\u0087",
            "\1\u0089",
            "\1\u008a",
            "\1\u008b",
            "\1\u008c\17\uffff\1\u008d",
            "\1\u008e",
            "\1\u008f",
            "\1\u0090",
            "\1\u0091",
            "\1\u0092",
            "\1\u0093",
            "\1\u0094",
            "\1\u0095",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\3\34\1\u0096\11"+
            "\34\1\u0097\14\34\5\uffff\uff7f\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u009a",
            "\1\u009b",
            "\1\u009c\4\uffff\1\u009d\7\uffff\1\u009e",
            "\1\u009f",
            "\1\u00a0\23\uffff\1\u00a1",
            "\1\u00a2",
            "\1\u00a3",
            "\1\u00a4",
            "\1\u00a5",
            "\1\u00a6",
            "\1\u00a7",
            "\1\u00a8",
            "\1\u00a9",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\3\34\1\u00ab\26"+
            "\34\5\uffff\uff7f\34",
            "\1\u00ad",
            "\1\u00ae\7\uffff\1\u00af",
            "\1\u00b0",
            "\1\u00b1",
            "\1\u00b2",
            "\1\u00b3\12\uffff\1\u00b4",
            "\1\u00b5",
            "\1\u00b6\3\uffff\1\u00b7\3\uffff\1\u00b8\13\uffff\1\u00b9",
            "\1\u00ba",
            "\1\u00bb",
            "\1\u00bc\13\uffff\1\u00bd",
            "\1\u00be",
            "\1\u00bf",
            "\12\141\13\uffff\1\155\37\uffff\2\155",
            "",
            "",
            "\1\u00c1\26\uffff\1\u00c1\122\uffff\1\u00c0",
            "",
            "",
            "\1\153\1\uffff\10\u00c2\2\u00c4\1\154\12\uffff\1\155\36\uffff"+
            "\1\156\2\155",
            "\1\153\1\uffff\12\u00c4\1\154\12\uffff\1\155\37\uffff\2\155",
            "",
            "",
            "\12\u00c5\13\uffff\1\155\37\uffff\2\155",
            "",
            "",
            "",
            "",
            "\12\141",
            "\1\153\1\uffff\10\u00c6\2\u00c7\13\uffff\1\155\6\uffff\1\152"+
            "\27\uffff\1\156\2\155\5\uffff\1\152",
            "\1\153\1\uffff\12\u00c8\13\uffff\1\155\6\uffff\1\152\27\uffff"+
            "\1\156\2\155\5\uffff\1\152",
            "\1\153\1\uffff\12\u00c9\1\154\12\uffff\1\155\6\uffff\1\152"+
            "\27\uffff\1\156\2\155\5\uffff\1\152",
            "",
            "",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u00d0",
            "\1\u00d1",
            "",
            "\1\u00d2",
            "\1\u00d3",
            "\1\u00d4",
            "\1\u00d5",
            "\1\u00d6",
            "\1\u00d7",
            "\1\u00d8",
            "\1\u00d9",
            "\1\u00da",
            "\1\u00db",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u00dd",
            "\1\u00de",
            "\1\u00df",
            "\1\u00e0",
            "\1\u00e1",
            "\1\u00e2",
            "\1\u00e3",
            "\1\u00e4",
            "\1\u00e5",
            "\1\u00e6",
            "\1\u00e7",
            "",
            "",
            "\1\u00e8",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u00ea",
            "\1\u00eb",
            "\1\u00ec",
            "\1\u00ed",
            "\1\u00ee",
            "\1\u00ef",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u00f1",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u00f6",
            "\1\u00f7",
            "",
            "\1\u00f8",
            "",
            "\1\u00f9",
            "\1\u00fa",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u00fc",
            "\1\u00fd",
            "\1\u00fe",
            "\1\u00ff",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0101",
            "\1\u0102",
            "\1\u0103",
            "\1\u0104",
            "\1\u0105",
            "\1\u0106",
            "\1\u0107",
            "\1\u0108",
            "\1\u0109",
            "\1\u010a",
            "\1\u010b\3\uffff\1\u010c",
            "",
            "",
            "\1\153\1\uffff\10\u010d\2\u010e\13\uffff\1\155\36\uffff\1"+
            "\156\2\155",
            "",
            "\1\153\1\uffff\12\u010e\13\uffff\1\155\37\uffff\2\155",
            "\12\u00c5\13\uffff\1\155\37\uffff\2\155",
            "\1\153\1\uffff\10\u00c6\2\u00c7\13\uffff\1\155\36\uffff\1"+
            "\156\2\155",
            "\1\153\1\uffff\12\u00c7\13\uffff\1\155\37\uffff\2\155",
            "\1\153\1\uffff\12\u00c8\13\uffff\1\155\6\uffff\1\152\27\uffff"+
            "\1\156\2\155\5\uffff\1\152",
            "\1\153\1\uffff\12\u010f\13\uffff\1\155\6\uffff\1\152\27\uffff"+
            "\1\156\2\155\5\uffff\1\152",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\u0110",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0113",
            "\1\u0114",
            "\1\u0115",
            "\1\u0116",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0118",
            "\1\u0119",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u011b",
            "",
            "\1\u011c",
            "\1\u011d",
            "\1\u011e",
            "\1\u011f",
            "\1\u0120",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0123",
            "\1\u0124",
            "\1\u0125",
            "\1\u0126",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\u0128",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u012a",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u012c",
            "\1\u012d",
            "",
            "\1\u012e",
            "",
            "",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\10\34\1\u012f\21"+
            "\34\5\uffff\uff7f\34",
            "\1\u0131",
            "\1\u0132",
            "\1\u0133",
            "\1\u0134",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0138",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u013a",
            "\1\u013b",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u013f",
            "\1\u0140",
            "\1\u0141",
            "\1\u0142",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0144",
            "\1\u0145\1\153\1\uffff\10\u00c6\2\u00c7\13\uffff\1\155\36"+
            "\uffff\1\156\2\155",
            "\1\u0145\1\153\1\uffff\12\u00c7\13\uffff\1\155\37\uffff\2"+
            "\155",
            "\1\u0145\1\153\1\uffff\12\u00c8\13\uffff\1\155\6\uffff\1\152"+
            "\27\uffff\1\156\2\155\5\uffff\1\152",
            "\1\u0146",
            "",
            "",
            "\1\u0147",
            "\1\u0148",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u014a",
            "",
            "\1\u014b",
            "\1\u014c",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u014f",
            "\1\u0150",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0154",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\u0157",
            "",
            "\1\u0158",
            "",
            "\1\u0159",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u015b",
            "\1\u015c",
            "",
            "\1\u015d",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0160",
            "",
            "",
            "",
            "\1\u0161",
            "",
            "\1\u0162",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "",
            "\1\u0164",
            "\1\u0165",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\u0169",
            "\1\u016a",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\u016c",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u016e",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "\1\u0172",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0179",
            "\1\u017a",
            "",
            "\1\u017b",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u017e",
            "",
            "\1\u017f",
            "",
            "\1\u0180",
            "",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\u0182",
            "\1\u0183",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\u0186\17\uffff\1\u0187",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\u0189",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "",
            "\1\u018b",
            "\1\u018c",
            "",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "",
            "\1\u018e",
            "\1\u018f",
            "",
            "\1\u0190",
            "\1\u0191",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\22\34\1\u0193\7"+
            "\34\5\uffff\uff7f\34",
            "",
            "\1\u0195",
            "",
            "\1\u0196",
            "\1\u0197",
            "\1\u0198",
            "\1\34\13\uffff\12\34\45\uffff\1\34\1\uffff\32\34\5\uffff\uff7f"+
            "\34",
            ""
    };

    static final short[] DFA35_eot = DFA.unpackEncodedString(DFA35_eotS);
    static final short[] DFA35_eof = DFA.unpackEncodedString(DFA35_eofS);
    static final char[] DFA35_min = DFA.unpackEncodedStringToUnsignedChars(DFA35_minS);
    static final char[] DFA35_max = DFA.unpackEncodedStringToUnsignedChars(DFA35_maxS);
    static final short[] DFA35_accept = DFA.unpackEncodedString(DFA35_acceptS);
    static final short[] DFA35_special = DFA.unpackEncodedString(DFA35_specialS);
    static final short[][] DFA35_transition;

    static {
        int numStates = DFA35_transitionS.length;
        DFA35_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA35_transition[i] = DFA.unpackEncodedString(DFA35_transitionS[i]);
        }
    }

    // Made static for performance reasons.
    static class DFA35 extends DFA {

        public DFA35(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 35;
            this.eot = DFA35_eot;
            this.eof = DFA35_eof;
            this.min = DFA35_min;
            this.max = DFA35_max;
            this.accept = DFA35_accept;
            this.special = DFA35_special;
            this.transition = DFA35_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( ABS | ALL | AND | ANY | AS | ASC | AVG | BETWEEN | BOTH | BY | CASE | COALESCE | CONCAT | COUNT | CURRENT_DATE | CURRENT_TIME | CURRENT_TIMESTAMP | DESC | DELETE | DISTINCT | ELSE | EMPTY | END | ENTRY | ESCAPE | EXISTS | FALSE | FETCH | FUNC | FROM | GROUP | HAVING | IN | INDEX | INNER | IS | JOIN | KEY | LEADING | LEFT | LENGTH | LIKE | LOCATE | LOWER | MAX | MEMBER | MIN | MOD | NEW | NOT | NULL | NULLIF | OBJECT | OF | OR | ORDER | OUTER | SELECT | SET | SIZE | SQRT | SOME | SUBSTRING | SUM | THEN | TRAILING | TREAT | TRIM | TRUE | TYPE | UNKNOWN | UPDATE | UPPER | VALUE | WHEN | WHERE | DOT | WS | LEFT_ROUND_BRACKET | LEFT_CURLY_BRACKET | RIGHT_ROUND_BRACKET | RIGHT_CURLY_BRACKET | COMMA | IDENT | HEX_LITERAL | INTEGER_LITERAL | LONG_LITERAL | OCTAL_LITERAL | DOUBLE_LITERAL | FLOAT_LITERAL | DATE_LITERAL | TIME_LITERAL | TIMESTAMP_LITERAL | DATE_STRING | TIME_STRING | EQUALS | GREATER_THAN | GREATER_THAN_EQUAL_TO | LESS_THAN | LESS_THAN_EQUAL_TO | NOT_EQUAL_TO | MULTIPLY | DIVIDE | PLUS | MINUS | POSITIONAL_PARAM | NAMED_PARAM | STRING_LITERAL_DOUBLE_QUOTED | STRING_LITERAL_SINGLE_QUOTED );";
        }
    }
 

}