// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 com/shin1ogawa/as3/AS3.g 2009-06-06 01:54:41

package jp.sourceforge.asclipse.as3;



import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
public class AS3Lexer extends Lexer {
    public static final int COMMA=66;
    public static final int CONST=9;
    public static final int AS=4;
    public static final int LF=120;
    public static final int XML_E_TEND=111;
    public static final int NUMBER=117;
    public static final int OR_ASSIGN=107;
    public static final int XOR_ASSIGN=106;
    public static final int FALSE=16;
    public static final int XML_ELLIPSIS=109;
    public static final int NAMESPACE=52;
    public static final int DEC_NUMBER_LITERAL=139;
    public static final int AND_ASSIGN=105;
    public static final int ADD_ASSIGN=100;
    public static final int IMPORT=22;
    public static final int PACKAGE=31;
    public static final int SHR=83;
    public static final int DEC_NUMBER=137;
    public static final int CONTINUE=10;
    public static final int DOT=65;
    public static final int PRIVATE=32;
    public static final int AND=85;
    public static final int TO=40;
    public static final int LCURLY=59;
    public static final int GET=50;
    public static final int FUNCTION=19;
    public static final int GTE=70;
    public static final int INCLUDE=53;
    public static final int XML_LS_STD=114;
    public static final int RPAREN=62;
    public static final int SINGLE_QUOTE_LITERAL=127;
    public static final int PLUS=75;
    public static final int FINALLY=17;
    public static final int EXTENDS=15;
    public static final int XML_TEXT=146;
    public static final int SHL_ASSIGN=102;
    public static final int SUPER=36;
    public static final int INTERNAL=26;
    public static final int SAME=73;
    public static final int XML_COMMENT=143;
    public static final int MOD_ASSIGN=99;
    public static final int NEW=29;
    public static final int EQ=71;
    public static final int LT=67;
    public static final int FINAL=55;
    public static final int DOLLAR=96;
    public static final int IDENT_PART=135;
    public static final int LAND=90;
    public static final int LBRACK=63;
    public static final int CATCH=7;
    public static final int STATIC=57;
    public static final int SEMI=58;
    public static final int CASE=6;
    public static final int INTERFACE=25;
    public static final int DIV_ASSIGN=98;
    public static final int INV=89;
    public static final int ELSE=14;
    public static final int XML_PI=145;
    public static final int BREAK=5;
    public static final int DYNAMIC=54;
    public static final int SUB_ASSIGN=101;
    public static final int NULL=30;
    public static final int XOR=87;
    public static final int COMMENT_MULTILINE=125;
    public static final int COLON=93;
    public static final int DIV=78;
    public static final int MUL_ASSIGN=97;
    public static final int IDENTIFIER=141;
    public static final int SET=51;
    public static final int TRUE=41;
    public static final int REGULAR_EXPR_FIRST_CHAR=132;
    public static final int UNDERSCORE=95;
    public static final int THROW=39;
    public static final int EACH=49;
    public static final int CR=119;
    public static final int PUBLIC=34;
    public static final int SHL=82;
    public static final int IDENT_NAME_ASCII_START=140;
    public static final int LOR=91;
    public static final int XML_NS_OP=112;
    public static final int TYPEOF=43;
    public static final int INC=80;
    public static final int DOUBLE_QUOTE_LITERAL=128;
    public static final int HEX_NUMBER_LITERAL=136;
    public static final int XML_AT=113;
    public static final int ELLIPSIS=108;
    public static final int MOD=79;
    public static final int OR=86;
    public static final int PROTECTED=33;
    public static final int RCURLY=60;
    public static final int UNICODE_ESCAPE=121;
    public static final int SHU=84;
    public static final int SHR_ASSIGN=103;
    public static final int ASSIGN=94;
    public static final int VOID=46;
    public static final int USE=44;
    public static final int INSTANCEOF=24;
    public static final int REGULAR_EXPR_FLAG=130;
    public static final int LPAREN=61;
    public static final int HEX_DIGIT=118;
    public static final int REGULAR_EXPR_BODY=129;
    public static final int XML_CDATA=144;
    public static final int NEQ=72;
    public static final int QUE=92;
    public static final int DELETE=12;
    public static final int COMMENT_SINGLELINE=126;
    public static final int DO=13;
    public static final int XML_TEND=110;
    public static final int IMPLEMENTS=21;
    public static final int BACKSLASH_SEQUENCE=134;
    public static final int WHILE=47;
    public static final int SWITCH=37;
    public static final int XML_LS_END=115;
    public static final int IS=27;
    public static final int REGULAR_EXPR_LITERAL=131;
    public static final int REGULAR_EXPR_CHAR=133;
    public static final int GT=68;
    public static final int IDENT_ASCII_START=142;
    public static final int OVERRIDE=56;
    public static final int THIS=38;
    public static final int WITH=48;
    public static final int WHITESPACE=124;
    public static final int IN=23;
    public static final int LTE=69;
    public static final int VAR=45;
    public static final int CLASS=8;
    public static final int NATIVE=28;
    public static final int DEC=81;
    public static final int RETURN=35;
    public static final int EXPONENT=138;
    public static final int ESCAPE_SEQUENCE=122;
    public static final int IF=20;
    public static final int ALPHABET=116;
    public static final int EOF=-1;
    public static final int EOL=123;
    public static final int FOR=18;
    public static final int RBRACK=64;
    public static final int DEFAULT=11;
    public static final int STAR=77;
    public static final int SHU_ASSIGN=104;
    public static final int SUB=76;
    public static final int NOT=88;
    public static final int TRY=42;
    public static final int NSAME=74;


    	/**  */
    	private Token lastDefaultCnlToken = null;

    	// override
    	public Token nextToken() {
    		Token result = super.nextToken();
    		if (result != null && result.getType() != WHITESPACE) {
    			lastDefaultCnlToken = result;
    		}
    		return result;
    	}

    	public void reset() {
    		super.reset(); // reset all recognizer state variables
    		if (input instanceof ANTLRStringStream) {
    			((ANTLRStringStream) input).reset();
    		}
    	}

    	// TODO: fix this so that regular expression embedded within xml text will
    	// work
    	private final boolean isRegularExpression() {
    		if (lastDefaultCnlToken != null) {
    			switch (lastDefaultCnlToken.getType()) {
    			case NULL:
    			case TRUE:
    			case FALSE:
    			case THIS:
    			case SUPER:
    			case IDENTIFIER:
    			case HEX_NUMBER_LITERAL:
    			case DEC_NUMBER_LITERAL:
    			case SINGLE_QUOTE_LITERAL:
    			case DOUBLE_QUOTE_LITERAL:
    			case RCURLY:
    			case RBRACK:
    			case RPAREN:
    				return false;
    			default:
    				break;
    			}
    		}

    		// start to predict if the next is a regular expression
    		int next = -1;
    		int index = 1;
    		boolean success = false;
    		if ((next = input.LA(index)) != '/') {
    			success = false;
    			return success;
    		}
    		index++;
    		// check the first regular character
    		next = input.LA(index);
    		if (next == '\r' || next == '\n' || next == '*' || next == '/'
    				|| next == '>') {
    			success = false;
    			return success;
    		} else if (next == '\\') {
    			next = input.LA(index + 1);
    			if (next == '\r' || next == '\n') {
    				success = false;
    				return success;
    			}
    			// we omit the escape sequence \ u XXXX or \ x XX
    			index++;
    		}
    		index++;
    		// check the body of regular character
    		while ((next = input.LA(index)) != -1) {
    			// System.out.println("char["+index+"] = ("+(char)next+")");
    			switch (next) {
    			case '\r':
    			case '\n':
    				success = false;
    				return success;
    			case '\\':
    				next = input.LA(index + 1);
    				if (next == '\r' || next == '\n') {
    					success = false;
    					return success;
    				}
    				// we omit the escape sequence \ u XXXX or \ x XX
    				index++;
    				break;
    			case '/':
    				success = true;
    				return success;
    			}
    			index++;
    		}
    		return success;
    	}

    	/**
    	 * <pre>
    	 * judge if is a XMLName
    	 * </pre>
    	 * 
    	 * @param ch
    	 *            character
    	 * @return if is a XMLName return true
    	 */
    	static final boolean isXMLText(int ch) {
    		return (ch != '{' && ch != '<' && !(isUnicodeIdentifierPart(ch)));
    	}

    	/*---------------------------UNICODE_INDENTIFER START------------------------------------------*/
    	private static final boolean isUnicodeIdentifierPart(int ch) {
    		return ch == '$' || ch == '_' || isUnicodeLetter(ch)
    				|| isUnicodeDigit(ch) || isUnicodeCombiningMark(ch)
    				|| isUnicodeConnectorPunctuation(ch);
    	}

    	private final void consumeIdentifierUnicodeStart()
    			throws RecognitionException, NoViableAltException {
    		int ch = input.LA(1);
    		if (isUnicodeLetter(ch) || ch == '$' || ch == '_') {
    			matchAny();
    			do {
    				ch = input.LA(1);
    				if (isUnicodeIdentifierPart(ch)) {
    					mIDENT_PART();
    				} else {
    					return;
    				}
    			} while (true);
    		} else {
    			throw new NoViableAltException();
    		}
    	}

    	/*---------------------------UNICODE_INDENTIFER END------------------------------------------*/

    	private static boolean isUnicodeLetter(int ch) {
    		return (ch >= '\u0041' && ch <= '\u005A')
    				|| (ch >= '\u0061' && ch <= '\u007A') || (ch == '\u00AA')
    				|| (ch == '\u00B5') || (ch == '\u00BA')
    				|| (ch >= '\u00C0' && ch <= '\u00D6')
    				|| (ch >= '\u00D8' && ch <= '\u00F6')
    				|| (ch >= '\u00F8' && ch <= '\u02C1')
    				|| (ch >= '\u02C6' && ch <= '\u02D1')
    				|| (ch >= '\u02E0' && ch <= '\u02E4') || (ch == '\u02EC')
    				|| (ch == '\u02EE') || (ch >= '\u0370' && ch <= '\u0374')
    				|| (ch >= '\u0376' && ch <= '\u037D') || (ch == '\u0386')
    				|| (ch >= '\u0388' && ch <= '\u03F5')
    				|| (ch >= '\u03F7' && ch <= '\u0481')
    				|| (ch >= '\u048A' && ch <= '\u0559')
    				|| (ch >= '\u0561' && ch <= '\u0587')
    				|| (ch >= '\u05D0' && ch <= '\u05F2')
    				|| (ch >= '\u0621' && ch <= '\u064A')
    				|| (ch >= '\u066E' && ch <= '\u066F')
    				|| (ch >= '\u0671' && ch <= '\u06D3') || (ch == '\u06D5')
    				|| (ch >= '\u06E5' && ch <= '\u06E6')
    				|| (ch >= '\u06EE' && ch <= '\u06EF')
    				|| (ch >= '\u06FA' && ch <= '\u06FC') || (ch == '\u06FF')
    				|| (ch == '\u0710') || (ch >= '\u0712' && ch <= '\u072F')
    				|| (ch >= '\u074D' && ch <= '\u07A5') || (ch == '\u07B1')
    				|| (ch >= '\u07CA' && ch <= '\u07EA')
    				|| (ch >= '\u07F4' && ch <= '\u07F5') || (ch == '\u07FA')
    				|| (ch >= '\u0904' && ch <= '\u0939') || (ch == '\u093D')
    				|| (ch == '\u0950') || (ch >= '\u0958' && ch <= '\u0961')
    				|| (ch >= '\u0971' && ch <= '\u097F')
    				|| (ch >= '\u0985' && ch <= '\u09B9') || (ch == '\u09BD')
    				|| (ch == '\u09CE') || (ch >= '\u09DC' && ch <= '\u09E1')
    				|| (ch >= '\u09F0' && ch <= '\u09F1')
    				|| (ch >= '\u0A05' && ch <= '\u0A39')
    				|| (ch >= '\u0A59' && ch <= '\u0A5E')
    				|| (ch >= '\u0A72' && ch <= '\u0A74')
    				|| (ch >= '\u0A85' && ch <= '\u0AB9') || (ch == '\u0ABD')
    				|| (ch >= '\u0AD0' && ch <= '\u0AE1')
    				|| (ch >= '\u0B05' && ch <= '\u0B39') || (ch == '\u0B3D')
    				|| (ch >= '\u0B5C' && ch <= '\u0B61') || (ch == '\u0B71')
    				|| (ch >= '\u0B83' && ch <= '\u0BB9') || (ch == '\u0BD0')
    				|| (ch >= '\u0C05' && ch <= '\u0C3D')
    				|| (ch >= '\u0C58' && ch <= '\u0C61')
    				|| (ch >= '\u0C85' && ch <= '\u0CB9') || (ch == '\u0CBD')
    				|| (ch >= '\u0CDE' && ch <= '\u0CE1')
    				|| (ch >= '\u0D05' && ch <= '\u0D3D')
    				|| (ch >= '\u0D60' && ch <= '\u0D61')
    				|| (ch >= '\u0D7A' && ch <= '\u0D7F')
    				|| (ch >= '\u0D85' && ch <= '\u0DC6')
    				|| (ch >= '\u0E01' && ch <= '\u0E30')
    				|| (ch >= '\u0E32' && ch <= '\u0E33')
    				|| (ch >= '\u0E40' && ch <= '\u0E46')
    				|| (ch >= '\u0E81' && ch <= '\u0EB0')
    				|| (ch >= '\u0EB2' && ch <= '\u0EB3')
    				|| (ch >= '\u0EBD' && ch <= '\u0EC6')
    				|| (ch >= '\u0EDC' && ch <= '\u0F00')
    				|| (ch >= '\u0F40' && ch <= '\u0F6C')
    				|| (ch >= '\u0F88' && ch <= '\u0F8B')
    				|| (ch >= '\u1000' && ch <= '\u102A') || (ch == '\u103F')
    				|| (ch >= '\u1050' && ch <= '\u1055')
    				|| (ch >= '\u105A' && ch <= '\u105D') || (ch == '\u1061')
    				|| (ch >= '\u1065' && ch <= '\u1066')
    				|| (ch >= '\u106E' && ch <= '\u1070')
    				|| (ch >= '\u1075' && ch <= '\u1081') || (ch == '\u108E')
    				|| (ch >= '\u10A0' && ch <= '\u10FA')
    				|| (ch >= '\u10FC' && ch <= '\u135A')
    				|| (ch >= '\u1380' && ch <= '\u138F')
    				|| (ch >= '\u13A0' && ch <= '\u166C')
    				|| (ch >= '\u166F' && ch <= '\u1676')
    				|| (ch >= '\u1681' && ch <= '\u169A')
    				|| (ch >= '\u16A0' && ch <= '\u16EA')
    				|| (ch >= '\u16EE' && ch <= '\u1711')
    				|| (ch >= '\u1720' && ch <= '\u1731')
    				|| (ch >= '\u1740' && ch <= '\u1751')
    				|| (ch >= '\u1760' && ch <= '\u1770')
    				|| (ch >= '\u1780' && ch <= '\u17B3') || (ch == '\u17D7')
    				|| (ch == '\u17DC') || (ch >= '\u1820' && ch <= '\u18A8')
    				|| (ch >= '\u18AA' && ch <= '\u191C')
    				|| (ch >= '\u1950' && ch <= '\u19A9')
    				|| (ch >= '\u19C1' && ch <= '\u19C7')
    				|| (ch >= '\u1A00' && ch <= '\u1A16')
    				|| (ch >= '\u1B05' && ch <= '\u1B33')
    				|| (ch >= '\u1B45' && ch <= '\u1B4B')
    				|| (ch >= '\u1B83' && ch <= '\u1BA0')
    				|| (ch >= '\u1BAE' && ch <= '\u1BAF')
    				|| (ch >= '\u1C00' && ch <= '\u1C23')
    				|| (ch >= '\u1C4D' && ch <= '\u1C4F')
    				|| (ch >= '\u1C5A' && ch <= '\u1C7D')
    				|| (ch >= '\u1D00' && ch <= '\u1DBF')
    				|| (ch >= '\u1E00' && ch <= '\u1FBC') || (ch == '\u1FBE')
    				|| (ch >= '\u1FC2' && ch <= '\u1FCC')
    				|| (ch >= '\u1FD0' && ch <= '\u1FDB')
    				|| (ch >= '\u1FE0' && ch <= '\u1FEC')
    				|| (ch >= '\u1FF2' && ch <= '\u1FFC') || (ch == '\u2071')
    				|| (ch == '\u207F') || (ch >= '\u2090' && ch <= '\u2094')
    				|| (ch == '\u2102') || (ch == '\u2107')
    				|| (ch >= '\u210A' && ch <= '\u2113') || (ch == '\u2115')
    				|| (ch >= '\u2119' && ch <= '\u211D') || (ch == '\u2124')
    				|| (ch == '\u2126') || (ch == '\u2128')
    				|| (ch >= '\u212A' && ch <= '\u212D')
    				|| (ch >= '\u212F' && ch <= '\u2139')
    				|| (ch >= '\u213C' && ch <= '\u213F')
    				|| (ch >= '\u2145' && ch <= '\u2149') || (ch == '\u214E')
    				|| (ch >= '\u2160' && ch <= '\u2188')
    				|| (ch >= '\u2C00' && ch <= '\u2CE4')
    				|| (ch >= '\u2D00' && ch <= '\u2DDE') || (ch == '\u2E2F')
    				|| (ch >= '\u3005' && ch <= '\u3007')
    				|| (ch >= '\u3021' && ch <= '\u3029')
    				|| (ch >= '\u3031' && ch <= '\u3035')
    				|| (ch >= '\u3038' && ch <= '\u303C')
    				|| (ch >= '\u3041' && ch <= '\u3096')
    				|| (ch >= '\u309D' && ch <= '\u309F')
    				|| (ch >= '\u30A1' && ch <= '\u30FA')
    				|| (ch >= '\u30FC' && ch <= '\u318E')
    				|| (ch >= '\u31A0' && ch <= '\u31B7')
    				|| (ch >= '\u31F0' && ch <= '\u31FF')
    				|| (ch >= '\u3400' && ch <= '\u4DB5')
    				|| (ch >= '\u4E00' && ch <= '\uA48C')
    				|| (ch >= '\uA500' && ch <= '\uA60C')
    				|| (ch >= '\uA610' && ch <= '\uA61F')
    				|| (ch >= '\uA62A' && ch <= '\uA66E')
    				|| (ch >= '\uA67F' && ch <= '\uA697')
    				|| (ch >= '\uA717' && ch <= '\uA71F')
    				|| (ch >= '\uA722' && ch <= '\uA788')
    				|| (ch >= '\uA78B' && ch <= '\uA801')
    				|| (ch >= '\uA803' && ch <= '\uA805')
    				|| (ch >= '\uA807' && ch <= '\uA80A')
    				|| (ch >= '\uA80C' && ch <= '\uA822')
    				|| (ch >= '\uA840' && ch <= '\uA873')
    				|| (ch >= '\uA882' && ch <= '\uA8B3')
    				|| (ch >= '\uA90A' && ch <= '\uA925')
    				|| (ch >= '\uA930' && ch <= '\uA946')
    				|| (ch >= '\uAA00' && ch <= '\uAA28')
    				|| (ch >= '\uAA40' && ch <= '\uAA42')
    				|| (ch >= '\uAA44' && ch <= '\uAA4B')
    				|| (ch >= '\uAC00' && ch <= '\uD7A3')
    				|| (ch >= '\uF900' && ch <= '\uFB1D')
    				|| (ch >= '\uFB1F' && ch <= '\uFB28')
    				|| (ch >= '\uFB2A' && ch <= '\uFD3D')
    				|| (ch >= '\uFD50' && ch <= '\uFDFB')
    				|| (ch >= '\uFE70' && ch <= '\uFEFC')
    				|| (ch >= '\uFF21' && ch <= '\uFF3A')
    				|| (ch >= '\uFF41' && ch <= '\uFF5A')
    				|| (ch >= '\uFF66' && ch <= '\uFFDC');
    	}

    	private static boolean isUnicodeCombiningMark(int ch) {
    		return (ch >= '\u0300' && ch <= '\u036F')
    				|| (ch >= '\u0483' && ch <= '\u0487')
    				|| (ch >= '\u0591' && ch <= '\u05BD') || (ch == '\u05BF')
    				|| (ch >= '\u05C1' && ch <= '\u05C2')
    				|| (ch >= '\u05C4' && ch <= '\u05C5') || (ch == '\u05C7')
    				|| (ch >= '\u0610' && ch <= '\u061A')
    				|| (ch >= '\u064B' && ch <= '\u065E') || (ch == '\u0670')
    				|| (ch >= '\u06D6' && ch <= '\u06DC')
    				|| (ch >= '\u06DF' && ch <= '\u06E4')
    				|| (ch >= '\u06E7' && ch <= '\u06E8')
    				|| (ch >= '\u06EA' && ch <= '\u06ED') || (ch == '\u0711')
    				|| (ch >= '\u0730' && ch <= '\u074A')
    				|| (ch >= '\u07A6' && ch <= '\u07B0')
    				|| (ch >= '\u07EB' && ch <= '\u07F3')
    				|| (ch >= '\u0901' && ch <= '\u0903') || (ch == '\u093C')
    				|| (ch >= '\u093E' && ch <= '\u094D')
    				|| (ch >= '\u0951' && ch <= '\u0954')
    				|| (ch >= '\u0962' && ch <= '\u0963')
    				|| (ch >= '\u0981' && ch <= '\u0983') || (ch == '\u09BC')
    				|| (ch >= '\u09BE' && ch <= '\u09CD') || (ch == '\u09D7')
    				|| (ch >= '\u09E2' && ch <= '\u09E3')
    				|| (ch >= '\u0A01' && ch <= '\u0A03')
    				|| (ch >= '\u0A3C' && ch <= '\u0A51')
    				|| (ch >= '\u0A70' && ch <= '\u0A71')
    				|| (ch >= '\u0A75' && ch <= '\u0A83') || (ch == '\u0ABC')
    				|| (ch >= '\u0ABE' && ch <= '\u0ACD')
    				|| (ch >= '\u0AE2' && ch <= '\u0AE3')
    				|| (ch >= '\u0B01' && ch <= '\u0B03') || (ch == '\u0B3C')
    				|| (ch >= '\u0B3E' && ch <= '\u0B57')
    				|| (ch >= '\u0B62' && ch <= '\u0B63') || (ch == '\u0B82')
    				|| (ch >= '\u0BBE' && ch <= '\u0BCD') || (ch == '\u0BD7')
    				|| (ch >= '\u0C01' && ch <= '\u0C03')
    				|| (ch >= '\u0C3E' && ch <= '\u0C56')
    				|| (ch >= '\u0C62' && ch <= '\u0C63')
    				|| (ch >= '\u0C82' && ch <= '\u0C83') || (ch == '\u0CBC')
    				|| (ch >= '\u0CBE' && ch <= '\u0CD6')
    				|| (ch >= '\u0CE2' && ch <= '\u0CE3')
    				|| (ch >= '\u0D02' && ch <= '\u0D03')
    				|| (ch >= '\u0D3E' && ch <= '\u0D57')
    				|| (ch >= '\u0D62' && ch <= '\u0D63')
    				|| (ch >= '\u0D82' && ch <= '\u0D83')
    				|| (ch >= '\u0DCA' && ch <= '\u0DF3') || (ch == '\u0E31')
    				|| (ch >= '\u0E34' && ch <= '\u0E3A')
    				|| (ch >= '\u0E47' && ch <= '\u0E4E') || (ch == '\u0EB1')
    				|| (ch >= '\u0EB4' && ch <= '\u0EBC')
    				|| (ch >= '\u0EC8' && ch <= '\u0ECD')
    				|| (ch >= '\u0F18' && ch <= '\u0F19') || (ch == '\u0F35')
    				|| (ch == '\u0F37') || (ch == '\u0F39')
    				|| (ch >= '\u0F3E' && ch <= '\u0F3F')
    				|| (ch >= '\u0F71' && ch <= '\u0F84')
    				|| (ch >= '\u0F86' && ch <= '\u0F87')
    				|| (ch >= '\u0F90' && ch <= '\u0FBC') || (ch == '\u0FC6')
    				|| (ch >= '\u102B' && ch <= '\u103E')
    				|| (ch >= '\u1056' && ch <= '\u1059')
    				|| (ch >= '\u105E' && ch <= '\u1060')
    				|| (ch >= '\u1062' && ch <= '\u1064')
    				|| (ch >= '\u1067' && ch <= '\u106D')
    				|| (ch >= '\u1071' && ch <= '\u1074')
    				|| (ch >= '\u1082' && ch <= '\u108D') || (ch == '\u108F')
    				|| (ch == '\u135F') || (ch >= '\u1712' && ch <= '\u1714')
    				|| (ch >= '\u1732' && ch <= '\u1734')
    				|| (ch >= '\u1752' && ch <= '\u1753')
    				|| (ch >= '\u1772' && ch <= '\u1773')
    				|| (ch >= '\u17B6' && ch <= '\u17D3') || (ch == '\u17DD')
    				|| (ch >= '\u180B' && ch <= '\u180D') || (ch == '\u18A9')
    				|| (ch >= '\u1920' && ch <= '\u193B')
    				|| (ch >= '\u19B0' && ch <= '\u19C0')
    				|| (ch >= '\u19C8' && ch <= '\u19C9')
    				|| (ch >= '\u1A17' && ch <= '\u1A1B')
    				|| (ch >= '\u1B00' && ch <= '\u1B04')
    				|| (ch >= '\u1B34' && ch <= '\u1B44')
    				|| (ch >= '\u1B6B' && ch <= '\u1B73')
    				|| (ch >= '\u1B80' && ch <= '\u1B82')
    				|| (ch >= '\u1BA1' && ch <= '\u1BAA')
    				|| (ch >= '\u1C24' && ch <= '\u1C37')
    				|| (ch >= '\u1DC0' && ch <= '\u1DFF')
    				|| (ch >= '\u20D0' && ch <= '\u20DC') || (ch == '\u20E1')
    				|| (ch >= '\u20E5' && ch <= '\u20F0')
    				|| (ch >= '\u2DE0' && ch <= '\u2DFF')
    				|| (ch >= '\u302A' && ch <= '\u302F')
    				|| (ch >= '\u3099' && ch <= '\u309A') || (ch == '\uA66F')
    				|| (ch >= '\uA67C' && ch <= '\uA67D') || (ch == '\uA802')
    				|| (ch == '\uA806') || (ch == '\uA80B')
    				|| (ch >= '\uA823' && ch <= '\uA827')
    				|| (ch >= '\uA880' && ch <= '\uA881')
    				|| (ch >= '\uA8B4' && ch <= '\uA8C4')
    				|| (ch >= '\uA926' && ch <= '\uA92D')
    				|| (ch >= '\uA947' && ch <= '\uA953')
    				|| (ch >= '\uAA29' && ch <= '\uAA36') || (ch == '\uAA43')
    				|| (ch >= '\uAA4C' && ch <= '\uAA4D') || (ch == '\uFB1E')
    				|| (ch >= '\uFE00' && ch <= '\uFE0F')
    				|| (ch >= '\uFE20' && ch <= '\uFE26');
    	}

    	private static boolean isUnicodeDigit(int ch) {
    		return (ch >= '\u0030' && ch <= '\u0039')
    				|| (ch >= '\u0660' && ch <= '\u0669')
    				|| (ch >= '\u06F0' && ch <= '\u06F9')
    				|| (ch >= '\u07C0' && ch <= '\u07C9')
    				|| (ch >= '\u0966' && ch <= '\u096F')
    				|| (ch >= '\u09E6' && ch <= '\u09EF')
    				|| (ch >= '\u0A66' && ch <= '\u0A6F')
    				|| (ch >= '\u0AE6' && ch <= '\u0AEF')
    				|| (ch >= '\u0B66' && ch <= '\u0B6F')
    				|| (ch >= '\u0BE6' && ch <= '\u0BEF')
    				|| (ch >= '\u0C66' && ch <= '\u0C6F')
    				|| (ch >= '\u0CE6' && ch <= '\u0CEF')
    				|| (ch >= '\u0D66' && ch <= '\u0D6F')
    				|| (ch >= '\u0E50' && ch <= '\u0E59')
    				|| (ch >= '\u0ED0' && ch <= '\u0ED9')
    				|| (ch >= '\u0F20' && ch <= '\u0F29')
    				|| (ch >= '\u1040' && ch <= '\u1049')
    				|| (ch >= '\u1090' && ch <= '\u1099')
    				|| (ch >= '\u17E0' && ch <= '\u17E9')
    				|| (ch >= '\u1810' && ch <= '\u1819')
    				|| (ch >= '\u1946' && ch <= '\u194F')
    				|| (ch >= '\u19D0' && ch <= '\u19D9')
    				|| (ch >= '\u1B50' && ch <= '\u1B59')
    				|| (ch >= '\u1BB0' && ch <= '\u1BB9')
    				|| (ch >= '\u1C40' && ch <= '\u1C49')
    				|| (ch >= '\u1C50' && ch <= '\u1C59')
    				|| (ch >= '\uA620' && ch <= '\uA629')
    				|| (ch >= '\uA8D0' && ch <= '\uA909')
    				|| (ch >= '\uAA50' && ch <= '\uAA59')
    				|| (ch >= '\uFF10' && ch <= '\uFF19');
    	}

    	private static boolean isUnicodeConnectorPunctuation(int ch) {
    		return (ch == '\u005F') || (ch >= '\u203F' && ch <= '\u2040')
    				|| (ch == '\u2054') || (ch >= '\uFE33' && ch <= '\uFE34')
    				|| (ch >= '\uFE4D' && ch <= '\uFE4F') || (ch == '\uFF3F');
    	}


    // delegates
    // delegators

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

    }
    public String getGrammarFileName() { return "com/shin1ogawa/as3/AS3.g"; }

    // $ANTLR start "AS"
    public final void mAS() throws RecognitionException {
        try {
            int _type = AS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:423:4: ( 'as' )
            // com/shin1ogawa/as3/AS3.g:423:6: 'as'
            {
            match("as"); if (state.failed) return ;


            }

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

    // $ANTLR start "BREAK"
    public final void mBREAK() throws RecognitionException {
        try {
            int _type = BREAK;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:424:7: ( 'break' )
            // com/shin1ogawa/as3/AS3.g:424:9: 'break'
            {
            match("break"); if (state.failed) return ;


            }

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

    // $ANTLR start "CASE"
    public final void mCASE() throws RecognitionException {
        try {
            int _type = CASE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:425:6: ( 'case' )
            // com/shin1ogawa/as3/AS3.g:425:8: 'case'
            {
            match("case"); if (state.failed) return ;


            }

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

    // $ANTLR start "CATCH"
    public final void mCATCH() throws RecognitionException {
        try {
            int _type = CATCH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:426:7: ( 'catch' )
            // com/shin1ogawa/as3/AS3.g:426:9: 'catch'
            {
            match("catch"); if (state.failed) return ;


            }

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

    // $ANTLR start "CLASS"
    public final void mCLASS() throws RecognitionException {
        try {
            int _type = CLASS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:427:7: ( 'class' )
            // com/shin1ogawa/as3/AS3.g:427:9: 'class'
            {
            match("class"); if (state.failed) return ;


            }

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

    // $ANTLR start "CONST"
    public final void mCONST() throws RecognitionException {
        try {
            int _type = CONST;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:428:7: ( 'const' )
            // com/shin1ogawa/as3/AS3.g:428:9: 'const'
            {
            match("const"); if (state.failed) return ;


            }

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

    // $ANTLR start "CONTINUE"
    public final void mCONTINUE() throws RecognitionException {
        try {
            int _type = CONTINUE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:429:10: ( 'continue' )
            // com/shin1ogawa/as3/AS3.g:429:12: 'continue'
            {
            match("continue"); if (state.failed) return ;


            }

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

    // $ANTLR start "DEFAULT"
    public final void mDEFAULT() throws RecognitionException {
        try {
            int _type = DEFAULT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:430:9: ( 'default' )
            // com/shin1ogawa/as3/AS3.g:430:11: 'default'
            {
            match("default"); if (state.failed) return ;


            }

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

    // $ANTLR start "DELETE"
    public final void mDELETE() throws RecognitionException {
        try {
            int _type = DELETE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:431:8: ( 'delete' )
            // com/shin1ogawa/as3/AS3.g:431:10: 'delete'
            {
            match("delete"); if (state.failed) return ;


            }

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

    // $ANTLR start "DO"
    public final void mDO() throws RecognitionException {
        try {
            int _type = DO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:432:4: ( 'do' )
            // com/shin1ogawa/as3/AS3.g:432:6: 'do'
            {
            match("do"); if (state.failed) return ;


            }

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

    // $ANTLR start "ELSE"
    public final void mELSE() throws RecognitionException {
        try {
            int _type = ELSE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:433:6: ( 'else' )
            // com/shin1ogawa/as3/AS3.g:433:8: 'else'
            {
            match("else"); if (state.failed) return ;


            }

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

    // $ANTLR start "EXTENDS"
    public final void mEXTENDS() throws RecognitionException {
        try {
            int _type = EXTENDS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:434:9: ( 'extends' )
            // com/shin1ogawa/as3/AS3.g:434:11: 'extends'
            {
            match("extends"); if (state.failed) return ;


            }

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

    // $ANTLR start "FALSE"
    public final void mFALSE() throws RecognitionException {
        try {
            int _type = FALSE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:435:7: ( 'false' )
            // com/shin1ogawa/as3/AS3.g:435:9: 'false'
            {
            match("false"); if (state.failed) return ;


            }

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

    // $ANTLR start "FINALLY"
    public final void mFINALLY() throws RecognitionException {
        try {
            int _type = FINALLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:436:9: ( 'finally' )
            // com/shin1ogawa/as3/AS3.g:436:11: 'finally'
            {
            match("finally"); if (state.failed) return ;


            }

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

    // $ANTLR start "FOR"
    public final void mFOR() throws RecognitionException {
        try {
            int _type = FOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:437:5: ( 'for' )
            // com/shin1ogawa/as3/AS3.g:437:7: 'for'
            {
            match("for"); if (state.failed) return ;


            }

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

    // $ANTLR start "FUNCTION"
    public final void mFUNCTION() throws RecognitionException {
        try {
            int _type = FUNCTION;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:438:10: ( 'function' )
            // com/shin1ogawa/as3/AS3.g:438:12: 'function'
            {
            match("function"); if (state.failed) return ;


            }

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

    // $ANTLR start "IF"
    public final void mIF() throws RecognitionException {
        try {
            int _type = IF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:439:4: ( 'if' )
            // com/shin1ogawa/as3/AS3.g:439:6: 'if'
            {
            match("if"); if (state.failed) return ;


            }

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

    // $ANTLR start "IMPLEMENTS"
    public final void mIMPLEMENTS() throws RecognitionException {
        try {
            int _type = IMPLEMENTS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:440:12: ( 'implements' )
            // com/shin1ogawa/as3/AS3.g:440:14: 'implements'
            {
            match("implements"); if (state.failed) return ;


            }

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

    // $ANTLR start "IMPORT"
    public final void mIMPORT() throws RecognitionException {
        try {
            int _type = IMPORT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:441:8: ( 'import' )
            // com/shin1ogawa/as3/AS3.g:441:10: 'import'
            {
            match("import"); if (state.failed) return ;


            }

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

    // $ANTLR start "IN"
    public final void mIN() throws RecognitionException {
        try {
            int _type = IN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:442:4: ( 'in' )
            // com/shin1ogawa/as3/AS3.g:442:6: 'in'
            {
            match("in"); if (state.failed) return ;


            }

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

    // $ANTLR start "INSTANCEOF"
    public final void mINSTANCEOF() throws RecognitionException {
        try {
            int _type = INSTANCEOF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:443:12: ( 'instanceof' )
            // com/shin1ogawa/as3/AS3.g:443:14: 'instanceof'
            {
            match("instanceof"); if (state.failed) return ;


            }

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

    // $ANTLR start "INTERFACE"
    public final void mINTERFACE() throws RecognitionException {
        try {
            int _type = INTERFACE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:444:11: ( 'interface' )
            // com/shin1ogawa/as3/AS3.g:444:13: 'interface'
            {
            match("interface"); if (state.failed) return ;


            }

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

    // $ANTLR start "INTERNAL"
    public final void mINTERNAL() throws RecognitionException {
        try {
            int _type = INTERNAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:445:10: ( 'internal' )
            // com/shin1ogawa/as3/AS3.g:445:12: 'internal'
            {
            match("internal"); if (state.failed) return ;


            }

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

    // $ANTLR start "IS"
    public final void mIS() throws RecognitionException {
        try {
            int _type = IS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:446:4: ( 'is' )
            // com/shin1ogawa/as3/AS3.g:446:6: 'is'
            {
            match("is"); if (state.failed) return ;


            }

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

    // $ANTLR start "NATIVE"
    public final void mNATIVE() throws RecognitionException {
        try {
            int _type = NATIVE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:447:8: ( 'native' )
            // com/shin1ogawa/as3/AS3.g:447:10: 'native'
            {
            match("native"); if (state.failed) return ;


            }

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

    // $ANTLR start "NEW"
    public final void mNEW() throws RecognitionException {
        try {
            int _type = NEW;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:448:5: ( 'new' )
            // com/shin1ogawa/as3/AS3.g:448:7: 'new'
            {
            match("new"); if (state.failed) return ;


            }

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

    // $ANTLR start "NULL"
    public final void mNULL() throws RecognitionException {
        try {
            int _type = NULL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:449:6: ( 'null' )
            // com/shin1ogawa/as3/AS3.g:449:8: 'null'
            {
            match("null"); if (state.failed) return ;


            }

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

    // $ANTLR start "PACKAGE"
    public final void mPACKAGE() throws RecognitionException {
        try {
            int _type = PACKAGE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:450:9: ( 'package' )
            // com/shin1ogawa/as3/AS3.g:450:11: 'package'
            {
            match("package"); if (state.failed) return ;


            }

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

    // $ANTLR start "PRIVATE"
    public final void mPRIVATE() throws RecognitionException {
        try {
            int _type = PRIVATE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:451:9: ( 'private' )
            // com/shin1ogawa/as3/AS3.g:451:11: 'private'
            {
            match("private"); if (state.failed) return ;


            }

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

    // $ANTLR start "PROTECTED"
    public final void mPROTECTED() throws RecognitionException {
        try {
            int _type = PROTECTED;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:452:11: ( 'protected' )
            // com/shin1ogawa/as3/AS3.g:452:13: 'protected'
            {
            match("protected"); if (state.failed) return ;


            }

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

    // $ANTLR start "PUBLIC"
    public final void mPUBLIC() throws RecognitionException {
        try {
            int _type = PUBLIC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:453:8: ( 'public' )
            // com/shin1ogawa/as3/AS3.g:453:10: 'public'
            {
            match("public"); if (state.failed) return ;


            }

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

    // $ANTLR start "RETURN"
    public final void mRETURN() throws RecognitionException {
        try {
            int _type = RETURN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:454:8: ( 'return' )
            // com/shin1ogawa/as3/AS3.g:454:10: 'return'
            {
            match("return"); if (state.failed) return ;


            }

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

    // $ANTLR start "SUPER"
    public final void mSUPER() throws RecognitionException {
        try {
            int _type = SUPER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:455:7: ( 'super' )
            // com/shin1ogawa/as3/AS3.g:455:9: 'super'
            {
            match("super"); if (state.failed) return ;


            }

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

    // $ANTLR start "SWITCH"
    public final void mSWITCH() throws RecognitionException {
        try {
            int _type = SWITCH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:456:8: ( 'switch' )
            // com/shin1ogawa/as3/AS3.g:456:10: 'switch'
            {
            match("switch"); if (state.failed) return ;


            }

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

    // $ANTLR start "THIS"
    public final void mTHIS() throws RecognitionException {
        try {
            int _type = THIS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:457:6: ( 'this' )
            // com/shin1ogawa/as3/AS3.g:457:8: 'this'
            {
            match("this"); if (state.failed) return ;


            }

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

    // $ANTLR start "THROW"
    public final void mTHROW() throws RecognitionException {
        try {
            int _type = THROW;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:458:7: ( 'throw' )
            // com/shin1ogawa/as3/AS3.g:458:9: 'throw'
            {
            match("throw"); if (state.failed) return ;


            }

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

    // $ANTLR start "TO"
    public final void mTO() throws RecognitionException {
        try {
            int _type = TO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:459:4: ( 'to' )
            // com/shin1ogawa/as3/AS3.g:459:6: 'to'
            {
            match("to"); if (state.failed) return ;


            }

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

    // $ANTLR start "TRUE"
    public final void mTRUE() throws RecognitionException {
        try {
            int _type = TRUE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:460:6: ( 'true' )
            // com/shin1ogawa/as3/AS3.g:460:8: 'true'
            {
            match("true"); if (state.failed) return ;


            }

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

    // $ANTLR start "TRY"
    public final void mTRY() throws RecognitionException {
        try {
            int _type = TRY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:461:5: ( 'try' )
            // com/shin1ogawa/as3/AS3.g:461:7: 'try'
            {
            match("try"); if (state.failed) return ;


            }

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

    // $ANTLR start "TYPEOF"
    public final void mTYPEOF() throws RecognitionException {
        try {
            int _type = TYPEOF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:462:8: ( 'typeof' )
            // com/shin1ogawa/as3/AS3.g:462:10: 'typeof'
            {
            match("typeof"); if (state.failed) return ;


            }

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

    // $ANTLR start "USE"
    public final void mUSE() throws RecognitionException {
        try {
            int _type = USE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:463:5: ( 'use' )
            // com/shin1ogawa/as3/AS3.g:463:7: 'use'
            {
            match("use"); if (state.failed) return ;


            }

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

    // $ANTLR start "VAR"
    public final void mVAR() throws RecognitionException {
        try {
            int _type = VAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:464:5: ( 'var' )
            // com/shin1ogawa/as3/AS3.g:464:7: 'var'
            {
            match("var"); if (state.failed) return ;


            }

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

    // $ANTLR start "VOID"
    public final void mVOID() throws RecognitionException {
        try {
            int _type = VOID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:465:6: ( 'void' )
            // com/shin1ogawa/as3/AS3.g:465:8: 'void'
            {
            match("void"); if (state.failed) return ;


            }

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

    // $ANTLR start "WHILE"
    public final void mWHILE() throws RecognitionException {
        try {
            int _type = WHILE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:466:7: ( 'while' )
            // com/shin1ogawa/as3/AS3.g:466:9: 'while'
            {
            match("while"); if (state.failed) return ;


            }

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

    // $ANTLR start "WITH"
    public final void mWITH() throws RecognitionException {
        try {
            int _type = WITH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:467:6: ( 'with' )
            // com/shin1ogawa/as3/AS3.g:467:8: 'with'
            {
            match("with"); if (state.failed) return ;


            }

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

    // $ANTLR start "EACH"
    public final void mEACH() throws RecognitionException {
        try {
            int _type = EACH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:468:6: ( 'each' )
            // com/shin1ogawa/as3/AS3.g:468:8: 'each'
            {
            match("each"); if (state.failed) return ;


            }

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

    // $ANTLR start "GET"
    public final void mGET() throws RecognitionException {
        try {
            int _type = GET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:469:5: ( 'get' )
            // com/shin1ogawa/as3/AS3.g:469:7: 'get'
            {
            match("get"); if (state.failed) return ;


            }

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

    // $ANTLR start "SET"
    public final void mSET() throws RecognitionException {
        try {
            int _type = SET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:470:5: ( 'set' )
            // com/shin1ogawa/as3/AS3.g:470:7: 'set'
            {
            match("set"); if (state.failed) return ;


            }

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

    // $ANTLR start "NAMESPACE"
    public final void mNAMESPACE() throws RecognitionException {
        try {
            int _type = NAMESPACE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:471:11: ( 'namespace' )
            // com/shin1ogawa/as3/AS3.g:471:13: 'namespace'
            {
            match("namespace"); if (state.failed) return ;


            }

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

    // $ANTLR start "INCLUDE"
    public final void mINCLUDE() throws RecognitionException {
        try {
            int _type = INCLUDE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:472:9: ( 'include' )
            // com/shin1ogawa/as3/AS3.g:472:11: 'include'
            {
            match("include"); if (state.failed) return ;


            }

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

    // $ANTLR start "DYNAMIC"
    public final void mDYNAMIC() throws RecognitionException {
        try {
            int _type = DYNAMIC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:473:9: ( 'dynamic' )
            // com/shin1ogawa/as3/AS3.g:473:11: 'dynamic'
            {
            match("dynamic"); if (state.failed) return ;


            }

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

    // $ANTLR start "FINAL"
    public final void mFINAL() throws RecognitionException {
        try {
            int _type = FINAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:474:7: ( 'final' )
            // com/shin1ogawa/as3/AS3.g:474:9: 'final'
            {
            match("final"); if (state.failed) return ;


            }

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

    // $ANTLR start "OVERRIDE"
    public final void mOVERRIDE() throws RecognitionException {
        try {
            int _type = OVERRIDE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:475:10: ( 'override' )
            // com/shin1ogawa/as3/AS3.g:475:12: 'override'
            {
            match("override"); if (state.failed) return ;


            }

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

    // $ANTLR start "STATIC"
    public final void mSTATIC() throws RecognitionException {
        try {
            int _type = STATIC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:476:8: ( 'static' )
            // com/shin1ogawa/as3/AS3.g:476:10: 'static'
            {
            match("static"); if (state.failed) return ;


            }

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

    // $ANTLR start "SEMI"
    public final void mSEMI() throws RecognitionException {
        try {
            int _type = SEMI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:477:6: ( ';' )
            // com/shin1ogawa/as3/AS3.g:477:8: ';'
            {
            match(';'); if (state.failed) return ;

            }

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

    // $ANTLR start "LCURLY"
    public final void mLCURLY() throws RecognitionException {
        try {
            int _type = LCURLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:478:8: ( '{' )
            // com/shin1ogawa/as3/AS3.g:478:10: '{'
            {
            match('{'); if (state.failed) return ;

            }

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

    // $ANTLR start "RCURLY"
    public final void mRCURLY() throws RecognitionException {
        try {
            int _type = RCURLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:479:8: ( '}' )
            // com/shin1ogawa/as3/AS3.g:479:10: '}'
            {
            match('}'); if (state.failed) return ;

            }

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

    // $ANTLR start "LPAREN"
    public final void mLPAREN() throws RecognitionException {
        try {
            int _type = LPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:480:8: ( '(' )
            // com/shin1ogawa/as3/AS3.g:480:10: '('
            {
            match('('); if (state.failed) return ;

            }

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

    // $ANTLR start "RPAREN"
    public final void mRPAREN() throws RecognitionException {
        try {
            int _type = RPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:481:8: ( ')' )
            // com/shin1ogawa/as3/AS3.g:481:10: ')'
            {
            match(')'); if (state.failed) return ;

            }

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

    // $ANTLR start "LBRACK"
    public final void mLBRACK() throws RecognitionException {
        try {
            int _type = LBRACK;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:482:8: ( '[' )
            // com/shin1ogawa/as3/AS3.g:482:10: '['
            {
            match('['); if (state.failed) return ;

            }

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

    // $ANTLR start "RBRACK"
    public final void mRBRACK() throws RecognitionException {
        try {
            int _type = RBRACK;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:483:8: ( ']' )
            // com/shin1ogawa/as3/AS3.g:483:10: ']'
            {
            match(']'); if (state.failed) return ;

            }

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

    // $ANTLR start "DOT"
    public final void mDOT() throws RecognitionException {
        try {
            int _type = DOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:484:5: ( '.' )
            // com/shin1ogawa/as3/AS3.g:484:7: '.'
            {
            match('.'); if (state.failed) return ;

            }

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

    // $ANTLR start "COMMA"
    public final void mCOMMA() throws RecognitionException {
        try {
            int _type = COMMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:485:7: ( ',' )
            // com/shin1ogawa/as3/AS3.g:485:9: ','
            {
            match(','); if (state.failed) return ;

            }

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

    // $ANTLR start "LT"
    public final void mLT() throws RecognitionException {
        try {
            int _type = LT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:486:4: ( '<' )
            // com/shin1ogawa/as3/AS3.g:486:6: '<'
            {
            match('<'); if (state.failed) return ;

            }

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

    // $ANTLR start "GT"
    public final void mGT() throws RecognitionException {
        try {
            int _type = GT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:487:4: ( '>' )
            // com/shin1ogawa/as3/AS3.g:487:6: '>'
            {
            match('>'); if (state.failed) return ;

            }

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

    // $ANTLR start "LTE"
    public final void mLTE() throws RecognitionException {
        try {
            int _type = LTE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:488:5: ( '<=' )
            // com/shin1ogawa/as3/AS3.g:488:7: '<='
            {
            match("<="); if (state.failed) return ;


            }

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

    // $ANTLR start "EQ"
    public final void mEQ() throws RecognitionException {
        try {
            int _type = EQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:489:4: ( '==' )
            // com/shin1ogawa/as3/AS3.g:489:6: '=='
            {
            match("=="); if (state.failed) return ;


            }

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

    // $ANTLR start "NEQ"
    public final void mNEQ() throws RecognitionException {
        try {
            int _type = NEQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:490:5: ( '!=' )
            // com/shin1ogawa/as3/AS3.g:490:7: '!='
            {
            match("!="); if (state.failed) return ;


            }

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

    // $ANTLR start "SAME"
    public final void mSAME() throws RecognitionException {
        try {
            int _type = SAME;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:491:6: ( '===' )
            // com/shin1ogawa/as3/AS3.g:491:8: '==='
            {
            match("==="); if (state.failed) return ;


            }

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

    // $ANTLR start "NSAME"
    public final void mNSAME() throws RecognitionException {
        try {
            int _type = NSAME;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:492:7: ( '!==' )
            // com/shin1ogawa/as3/AS3.g:492:9: '!=='
            {
            match("!=="); if (state.failed) return ;


            }

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

    // $ANTLR start "PLUS"
    public final void mPLUS() throws RecognitionException {
        try {
            int _type = PLUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:493:6: ( '+' )
            // com/shin1ogawa/as3/AS3.g:493:8: '+'
            {
            match('+'); if (state.failed) return ;

            }

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

    // $ANTLR start "SUB"
    public final void mSUB() throws RecognitionException {
        try {
            int _type = SUB;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:494:5: ( '-' )
            // com/shin1ogawa/as3/AS3.g:494:7: '-'
            {
            match('-'); if (state.failed) return ;

            }

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

    // $ANTLR start "STAR"
    public final void mSTAR() throws RecognitionException {
        try {
            int _type = STAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:495:6: ( '*' )
            // com/shin1ogawa/as3/AS3.g:495:8: '*'
            {
            match('*'); if (state.failed) return ;

            }

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

    // $ANTLR start "DIV"
    public final void mDIV() throws RecognitionException {
        try {
            int _type = DIV;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:496:5: ( '/' )
            // com/shin1ogawa/as3/AS3.g:496:7: '/'
            {
            match('/'); if (state.failed) return ;

            }

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

    // $ANTLR start "MOD"
    public final void mMOD() throws RecognitionException {
        try {
            int _type = MOD;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:497:5: ( '%' )
            // com/shin1ogawa/as3/AS3.g:497:7: '%'
            {
            match('%'); if (state.failed) return ;

            }

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

    // $ANTLR start "INC"
    public final void mINC() throws RecognitionException {
        try {
            int _type = INC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:498:5: ( '++' )
            // com/shin1ogawa/as3/AS3.g:498:7: '++'
            {
            match("++"); if (state.failed) return ;


            }

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

    // $ANTLR start "DEC"
    public final void mDEC() throws RecognitionException {
        try {
            int _type = DEC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:499:5: ( '--' )
            // com/shin1ogawa/as3/AS3.g:499:7: '--'
            {
            match("--"); if (state.failed) return ;


            }

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

    // $ANTLR start "SHL"
    public final void mSHL() throws RecognitionException {
        try {
            int _type = SHL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:500:5: ( '<<' )
            // com/shin1ogawa/as3/AS3.g:500:7: '<<'
            {
            match("<<"); if (state.failed) return ;


            }

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

    // $ANTLR start "SHR"
    public final void mSHR() throws RecognitionException {
        try {
            int _type = SHR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:501:5: ( '>>' )
            // com/shin1ogawa/as3/AS3.g:501:7: '>>'
            {
            match(">>"); if (state.failed) return ;


            }

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

    // $ANTLR start "SHU"
    public final void mSHU() throws RecognitionException {
        try {
            int _type = SHU;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:502:5: ( '>>>' )
            // com/shin1ogawa/as3/AS3.g:502:7: '>>>'
            {
            match(">>>"); if (state.failed) return ;


            }

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

    // $ANTLR start "AND"
    public final void mAND() throws RecognitionException {
        try {
            int _type = AND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:503:5: ( '&' )
            // com/shin1ogawa/as3/AS3.g:503:7: '&'
            {
            match('&'); if (state.failed) return ;

            }

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

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:504:4: ( '|' )
            // com/shin1ogawa/as3/AS3.g:504:6: '|'
            {
            match('|'); if (state.failed) return ;

            }

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

    // $ANTLR start "XOR"
    public final void mXOR() throws RecognitionException {
        try {
            int _type = XOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:505:5: ( '^' )
            // com/shin1ogawa/as3/AS3.g:505:7: '^'
            {
            match('^'); if (state.failed) return ;

            }

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

    // $ANTLR start "NOT"
    public final void mNOT() throws RecognitionException {
        try {
            int _type = NOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:506:5: ( '!' )
            // com/shin1ogawa/as3/AS3.g:506:7: '!'
            {
            match('!'); if (state.failed) return ;

            }

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

    // $ANTLR start "INV"
    public final void mINV() throws RecognitionException {
        try {
            int _type = INV;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:507:5: ( '~' )
            // com/shin1ogawa/as3/AS3.g:507:7: '~'
            {
            match('~'); if (state.failed) return ;

            }

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

    // $ANTLR start "LAND"
    public final void mLAND() throws RecognitionException {
        try {
            int _type = LAND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:508:6: ( '&&' )
            // com/shin1ogawa/as3/AS3.g:508:8: '&&'
            {
            match("&&"); if (state.failed) return ;


            }

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

    // $ANTLR start "LOR"
    public final void mLOR() throws RecognitionException {
        try {
            int _type = LOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:509:5: ( '||' )
            // com/shin1ogawa/as3/AS3.g:509:7: '||'
            {
            match("||"); if (state.failed) return ;


            }

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

    // $ANTLR start "QUE"
    public final void mQUE() throws RecognitionException {
        try {
            int _type = QUE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:510:5: ( '?' )
            // com/shin1ogawa/as3/AS3.g:510:7: '?'
            {
            match('?'); if (state.failed) return ;

            }

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

    // $ANTLR start "COLON"
    public final void mCOLON() throws RecognitionException {
        try {
            int _type = COLON;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:511:7: ( ':' )
            // com/shin1ogawa/as3/AS3.g:511:9: ':'
            {
            match(':'); if (state.failed) return ;

            }

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

    // $ANTLR start "ASSIGN"
    public final void mASSIGN() throws RecognitionException {
        try {
            int _type = ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:512:8: ( '=' )
            // com/shin1ogawa/as3/AS3.g:512:10: '='
            {
            match('='); if (state.failed) return ;

            }

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

    // $ANTLR start "UNDERSCORE"
    public final void mUNDERSCORE() throws RecognitionException {
        try {
            int _type = UNDERSCORE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:513:12: ( '_' )
            // com/shin1ogawa/as3/AS3.g:513:14: '_'
            {
            match('_'); if (state.failed) return ;

            }

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

    // $ANTLR start "DOLLAR"
    public final void mDOLLAR() throws RecognitionException {
        try {
            int _type = DOLLAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:514:8: ( '$' )
            // com/shin1ogawa/as3/AS3.g:514:10: '$'
            {
            match('$'); if (state.failed) return ;

            }

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

    // $ANTLR start "MUL_ASSIGN"
    public final void mMUL_ASSIGN() throws RecognitionException {
        try {
            int _type = MUL_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:515:12: ( '*=' )
            // com/shin1ogawa/as3/AS3.g:515:14: '*='
            {
            match("*="); if (state.failed) return ;


            }

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

    // $ANTLR start "DIV_ASSIGN"
    public final void mDIV_ASSIGN() throws RecognitionException {
        try {
            int _type = DIV_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:516:12: ( '/=' )
            // com/shin1ogawa/as3/AS3.g:516:14: '/='
            {
            match("/="); if (state.failed) return ;


            }

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

    // $ANTLR start "MOD_ASSIGN"
    public final void mMOD_ASSIGN() throws RecognitionException {
        try {
            int _type = MOD_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:517:12: ( '%=' )
            // com/shin1ogawa/as3/AS3.g:517:14: '%='
            {
            match("%="); if (state.failed) return ;


            }

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

    // $ANTLR start "ADD_ASSIGN"
    public final void mADD_ASSIGN() throws RecognitionException {
        try {
            int _type = ADD_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:518:12: ( '+=' )
            // com/shin1ogawa/as3/AS3.g:518:14: '+='
            {
            match("+="); if (state.failed) return ;


            }

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

    // $ANTLR start "SUB_ASSIGN"
    public final void mSUB_ASSIGN() throws RecognitionException {
        try {
            int _type = SUB_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:519:12: ( '-=' )
            // com/shin1ogawa/as3/AS3.g:519:14: '-='
            {
            match("-="); if (state.failed) return ;


            }

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

    // $ANTLR start "SHL_ASSIGN"
    public final void mSHL_ASSIGN() throws RecognitionException {
        try {
            int _type = SHL_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:520:12: ( '<<=' )
            // com/shin1ogawa/as3/AS3.g:520:14: '<<='
            {
            match("<<="); if (state.failed) return ;


            }

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

    // $ANTLR start "SHR_ASSIGN"
    public final void mSHR_ASSIGN() throws RecognitionException {
        try {
            int _type = SHR_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:521:12: ( '>>=' )
            // com/shin1ogawa/as3/AS3.g:521:14: '>>='
            {
            match(">>="); if (state.failed) return ;


            }

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

    // $ANTLR start "SHU_ASSIGN"
    public final void mSHU_ASSIGN() throws RecognitionException {
        try {
            int _type = SHU_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:522:12: ( '>>>=' )
            // com/shin1ogawa/as3/AS3.g:522:14: '>>>='
            {
            match(">>>="); if (state.failed) return ;


            }

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

    // $ANTLR start "AND_ASSIGN"
    public final void mAND_ASSIGN() throws RecognitionException {
        try {
            int _type = AND_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:523:12: ( '&=' )
            // com/shin1ogawa/as3/AS3.g:523:14: '&='
            {
            match("&="); if (state.failed) return ;


            }

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

    // $ANTLR start "XOR_ASSIGN"
    public final void mXOR_ASSIGN() throws RecognitionException {
        try {
            int _type = XOR_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:524:12: ( '^=' )
            // com/shin1ogawa/as3/AS3.g:524:14: '^='
            {
            match("^="); if (state.failed) return ;


            }

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

    // $ANTLR start "OR_ASSIGN"
    public final void mOR_ASSIGN() throws RecognitionException {
        try {
            int _type = OR_ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:525:11: ( '|=' )
            // com/shin1ogawa/as3/AS3.g:525:13: '|='
            {
            match("|="); if (state.failed) return ;


            }

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

    // $ANTLR start "ELLIPSIS"
    public final void mELLIPSIS() throws RecognitionException {
        try {
            int _type = ELLIPSIS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:526:10: ( '...' )
            // com/shin1ogawa/as3/AS3.g:526:12: '...'
            {
            match("..."); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_ELLIPSIS"
    public final void mXML_ELLIPSIS() throws RecognitionException {
        try {
            int _type = XML_ELLIPSIS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:527:14: ( '..' )
            // com/shin1ogawa/as3/AS3.g:527:16: '..'
            {
            match(".."); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_TEND"
    public final void mXML_TEND() throws RecognitionException {
        try {
            int _type = XML_TEND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:528:10: ( '/>' )
            // com/shin1ogawa/as3/AS3.g:528:12: '/>'
            {
            match("/>"); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_E_TEND"
    public final void mXML_E_TEND() throws RecognitionException {
        try {
            int _type = XML_E_TEND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:529:12: ( '</' )
            // com/shin1ogawa/as3/AS3.g:529:14: '</'
            {
            match("</"); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_NS_OP"
    public final void mXML_NS_OP() throws RecognitionException {
        try {
            int _type = XML_NS_OP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:530:11: ( '::' )
            // com/shin1ogawa/as3/AS3.g:530:13: '::'
            {
            match("::"); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_AT"
    public final void mXML_AT() throws RecognitionException {
        try {
            int _type = XML_AT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:531:8: ( '@' )
            // com/shin1ogawa/as3/AS3.g:531:10: '@'
            {
            match('@'); if (state.failed) return ;

            }

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

    // $ANTLR start "XML_LS_STD"
    public final void mXML_LS_STD() throws RecognitionException {
        try {
            int _type = XML_LS_STD;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:532:12: ( '<>' )
            // com/shin1ogawa/as3/AS3.g:532:14: '<>'
            {
            match("<>"); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_LS_END"
    public final void mXML_LS_END() throws RecognitionException {
        try {
            int _type = XML_LS_END;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:533:12: ( '</>' )
            // com/shin1ogawa/as3/AS3.g:533:14: '</>'
            {
            match("</>"); if (state.failed) return ;


            }

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

    // $ANTLR start "ALPHABET"
    public final void mALPHABET() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:673:2: ( 'a' .. 'z' | 'A' .. 'Z' )
            // com/shin1ogawa/as3/AS3.g:
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();
            state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

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

    // $ANTLR start "NUMBER"
    public final void mNUMBER() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:676:2: ( '0' .. '9' )
            // com/shin1ogawa/as3/AS3.g:676:4: '0' .. '9'
            {
            matchRange('0','9'); if (state.failed) return ;

            }

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

    // $ANTLR start "HEX_DIGIT"
    public final void mHEX_DIGIT() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:679:2: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
            // com/shin1ogawa/as3/AS3.g:679:4: ( '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();
            state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

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

    // $ANTLR start "CR"
    public final void mCR() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:682:2: ( '\\r' )
            // com/shin1ogawa/as3/AS3.g:682:4: '\\r'
            {
            match('\r'); if (state.failed) return ;

            }

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

    // $ANTLR start "LF"
    public final void mLF() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:685:2: ( '\\n' )
            // com/shin1ogawa/as3/AS3.g:685:4: '\\n'
            {
            match('\n'); if (state.failed) return ;

            }

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

    // $ANTLR start "UNICODE_ESCAPE"
    public final void mUNICODE_ESCAPE() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:688:2: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
            // com/shin1ogawa/as3/AS3.g:688:4: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
            {
            match('\\'); if (state.failed) return ;
            match('u'); if (state.failed) return ;
            mHEX_DIGIT(); if (state.failed) return ;
            mHEX_DIGIT(); if (state.failed) return ;
            mHEX_DIGIT(); if (state.failed) return ;
            mHEX_DIGIT(); if (state.failed) return ;

            }

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

    // $ANTLR start "ESCAPE_SEQUENCE"
    public final void mESCAPE_SEQUENCE() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:691:2: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESCAPE )
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0=='\\') ) {
                int LA1_1 = input.LA(2);

                if ( (LA1_1=='\"'||LA1_1=='\''||LA1_1=='\\'||LA1_1=='b'||LA1_1=='f'||LA1_1=='n'||LA1_1=='r'||LA1_1=='t') ) {
                    alt1=1;
                }
                else if ( (LA1_1=='u') ) {
                    alt1=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 1, 1, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }
            switch (alt1) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:691:4: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
                    {
                    match('\\'); if (state.failed) return ;
                    if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t' ) {
                        input.consume();
                    state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;
                case 2 :
                    // com/shin1ogawa/as3/AS3.g:691:48: UNICODE_ESCAPE
                    {
                    mUNICODE_ESCAPE(); if (state.failed) return ;

                    }
                    break;

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

    // $ANTLR start "EOL"
    public final void mEOL() throws RecognitionException {
        try {
            int _type = EOL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:696:2: ( ( CR )? LF )
            // com/shin1ogawa/as3/AS3.g:696:4: ( CR )? LF
            {
            // com/shin1ogawa/as3/AS3.g:696:4: ( CR )?
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0=='\r') ) {
                alt2=1;
            }
            switch (alt2) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:696:4: CR
                    {
                    mCR(); if (state.failed) return ;

                    }
                    break;

            }

            mLF(); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               _channel = AS3Parser.CHANNEL_EOL; 
            }

            }

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

    // $ANTLR start "WHITESPACE"
    public final void mWHITESPACE() throws RecognitionException {
        try {
            int _type = WHITESPACE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:700:2: ( ( ( '\\u0020' | '\\u0009' | '\\u000B' | '\\u000C' ) | ( '\\u001C' .. '\\u001F' ) )+ )
            // com/shin1ogawa/as3/AS3.g:700:4: ( ( '\\u0020' | '\\u0009' | '\\u000B' | '\\u000C' ) | ( '\\u001C' .. '\\u001F' ) )+
            {
            // com/shin1ogawa/as3/AS3.g:700:4: ( ( '\\u0020' | '\\u0009' | '\\u000B' | '\\u000C' ) | ( '\\u001C' .. '\\u001F' ) )+
            int cnt3=0;
            loop3:
            do {
                int alt3=3;
                int LA3_0 = input.LA(1);

                if ( (LA3_0=='\t'||(LA3_0>='\u000B' && LA3_0<='\f')||LA3_0==' ') ) {
                    alt3=1;
                }
                else if ( ((LA3_0>='\u001C' && LA3_0<='\u001F')) ) {
                    alt3=2;
                }


                switch (alt3) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:700:5: ( '\\u0020' | '\\u0009' | '\\u000B' | '\\u000C' )
            	    {
            	    if ( input.LA(1)=='\t'||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||input.LA(1)==' ' ) {
            	        input.consume();
            	    state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;
            	case 2 :
            	    // com/shin1ogawa/as3/AS3.g:700:43: ( '\\u001C' .. '\\u001F' )
            	    {
            	    // com/shin1ogawa/as3/AS3.g:700:43: ( '\\u001C' .. '\\u001F' )
            	    // com/shin1ogawa/as3/AS3.g:700:44: '\\u001C' .. '\\u001F'
            	    {
            	    matchRange('\u001C','\u001F'); if (state.failed) return ;

            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt3 >= 1 ) break loop3;
            	    if (state.backtracking>0) {state.failed=true; return ;}
                        EarlyExitException eee =
                            new EarlyExitException(3, input);
                        throw eee;
                }
                cnt3++;
            } while (true);

            if ( state.backtracking==0 ) {
               _channel = AS3Parser.CHANNEL_WHITESPACE; 
            }

            }

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

    // $ANTLR start "COMMENT_MULTILINE"
    public final void mCOMMENT_MULTILINE() throws RecognitionException {
        try {
            int _type = COMMENT_MULTILINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:704:2: ( '/*' ( options {greedy=false; } : . )* '*/' )
            // com/shin1ogawa/as3/AS3.g:704:4: '/*' ( options {greedy=false; } : . )* '*/'
            {
            match("/*"); if (state.failed) return ;

            // com/shin1ogawa/as3/AS3.g:704:9: ( options {greedy=false; } : . )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0=='*') ) {
                    int LA4_1 = input.LA(2);

                    if ( (LA4_1=='/') ) {
                        alt4=2;
                    }
                    else if ( ((LA4_1>='\u0000' && LA4_1<='.')||(LA4_1>='0' && LA4_1<='\uFFFF')) ) {
                        alt4=1;
                    }


                }
                else if ( ((LA4_0>='\u0000' && LA4_0<=')')||(LA4_0>='+' && LA4_0<='\uFFFF')) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:704:37: .
            	    {
            	    matchAny(); if (state.failed) return ;

            	    }
            	    break;

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

            match("*/"); if (state.failed) return ;

            if ( state.backtracking==0 ) {
               _channel = AS3Parser.CHANNEL_MLCOMMENT; 
            }

            }

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

    // $ANTLR start "COMMENT_SINGLELINE"
    public final void mCOMMENT_SINGLELINE() throws RecognitionException {
        try {
            int _type = COMMENT_SINGLELINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:708:2: ( '//' (~ ( CR | LF ) )* ( CR )? LF )
            // com/shin1ogawa/as3/AS3.g:708:4: '//' (~ ( CR | LF ) )* ( CR )? LF
            {
            match("//"); if (state.failed) return ;

            // com/shin1ogawa/as3/AS3.g:708:9: (~ ( CR | LF ) )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( ((LA5_0>='\u0000' && LA5_0<='\t')||(LA5_0>='\u000B' && LA5_0<='\f')||(LA5_0>='\u000E' && LA5_0<='\uFFFF')) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:708:9: ~ ( CR | LF )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();
            	    state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

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

            // com/shin1ogawa/as3/AS3.g:708:21: ( CR )?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0=='\r') ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:708:21: CR
                    {
                    mCR(); if (state.failed) return ;

                    }
                    break;

            }

            mLF(); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               _channel = AS3Parser.CHANNEL_SLCOMMENT; 
            }

            }

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

    // $ANTLR start "SINGLE_QUOTE_LITERAL"
    public final void mSINGLE_QUOTE_LITERAL() throws RecognitionException {
        try {
            int _type = SINGLE_QUOTE_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:714:2: ( '\\'' ( ESCAPE_SEQUENCE | ~ ( '\\\\' | '\\'' ) )* '\\'' )
            // com/shin1ogawa/as3/AS3.g:714:4: '\\'' ( ESCAPE_SEQUENCE | ~ ( '\\\\' | '\\'' ) )* '\\''
            {
            match('\''); if (state.failed) return ;
            // com/shin1ogawa/as3/AS3.g:714:9: ( ESCAPE_SEQUENCE | ~ ( '\\\\' | '\\'' ) )*
            loop7:
            do {
                int alt7=3;
                int LA7_0 = input.LA(1);

                if ( (LA7_0=='\\') ) {
                    alt7=1;
                }
                else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) {
                    alt7=2;
                }


                switch (alt7) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:714:10: ESCAPE_SEQUENCE
            	    {
            	    mESCAPE_SEQUENCE(); if (state.failed) return ;

            	    }
            	    break;
            	case 2 :
            	    // com/shin1ogawa/as3/AS3.g:714:28: ~ ( '\\\\' | '\\'' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();
            	    state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

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

            match('\''); if (state.failed) return ;

            }

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

    // $ANTLR start "DOUBLE_QUOTE_LITERAL"
    public final void mDOUBLE_QUOTE_LITERAL() throws RecognitionException {
        try {
            int _type = DOUBLE_QUOTE_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:717:2: ( '\"' ( ESCAPE_SEQUENCE | ~ ( '\\\\' | '\"' ) )* '\"' )
            // com/shin1ogawa/as3/AS3.g:717:4: '\"' ( ESCAPE_SEQUENCE | ~ ( '\\\\' | '\"' ) )* '\"'
            {
            match('\"'); if (state.failed) return ;
            // com/shin1ogawa/as3/AS3.g:717:8: ( ESCAPE_SEQUENCE | ~ ( '\\\\' | '\"' ) )*
            loop8:
            do {
                int alt8=3;
                int LA8_0 = input.LA(1);

                if ( (LA8_0=='\\') ) {
                    alt8=1;
                }
                else if ( ((LA8_0>='\u0000' && LA8_0<='!')||(LA8_0>='#' && LA8_0<='[')||(LA8_0>=']' && LA8_0<='\uFFFF')) ) {
                    alt8=2;
                }


                switch (alt8) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:717:9: ESCAPE_SEQUENCE
            	    {
            	    mESCAPE_SEQUENCE(); if (state.failed) return ;

            	    }
            	    break;
            	case 2 :
            	    // com/shin1ogawa/as3/AS3.g:717:27: ~ ( '\\\\' | '\"' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();
            	    state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

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

            match('\"'); if (state.failed) return ;

            }

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

    // $ANTLR start "REGULAR_EXPR_LITERAL"
    public final void mREGULAR_EXPR_LITERAL() throws RecognitionException {
        try {
            int _type = REGULAR_EXPR_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:723:2: ({...}? => DIV REGULAR_EXPR_BODY DIV ( REGULAR_EXPR_FLAG )* )
            // com/shin1ogawa/as3/AS3.g:723:4: {...}? => DIV REGULAR_EXPR_BODY DIV ( REGULAR_EXPR_FLAG )*
            {
            if ( !((isRegularExpression())) ) {
                if (state.backtracking>0) {state.failed=true; return ;}
                throw new FailedPredicateException(input, "REGULAR_EXPR_LITERAL", "isRegularExpression()");
            }
            mDIV(); if (state.failed) return ;
            mREGULAR_EXPR_BODY(); if (state.failed) return ;
            mDIV(); if (state.failed) return ;
            // com/shin1ogawa/as3/AS3.g:723:58: ( REGULAR_EXPR_FLAG )*
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( (LA9_0=='$'||(LA9_0>='0' && LA9_0<='9')||(LA9_0>='A' && LA9_0<='Z')||LA9_0=='_'||(LA9_0>='a' && LA9_0<='z')) ) {
                    alt9=1;
                }
                else if ( ((isUnicodeIdentifierPart(input.LA(1)))) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:723:58: REGULAR_EXPR_FLAG
            	    {
            	    mREGULAR_EXPR_FLAG(); if (state.failed) return ;

            	    }
            	    break;

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


            }

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

    // $ANTLR start "REGULAR_EXPR_BODY"
    public final void mREGULAR_EXPR_BODY() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:727:2: ( REGULAR_EXPR_FIRST_CHAR ( REGULAR_EXPR_CHAR )* )
            // com/shin1ogawa/as3/AS3.g:727:4: REGULAR_EXPR_FIRST_CHAR ( REGULAR_EXPR_CHAR )*
            {
            mREGULAR_EXPR_FIRST_CHAR(); if (state.failed) return ;
            // com/shin1ogawa/as3/AS3.g:727:28: ( REGULAR_EXPR_CHAR )*
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( ((LA10_0>='\u0000' && LA10_0<='\t')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='.')||(LA10_0>='0' && LA10_0<='\uFFFF')) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:727:28: REGULAR_EXPR_CHAR
            	    {
            	    mREGULAR_EXPR_CHAR(); if (state.failed) return ;

            	    }
            	    break;

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


            }

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

    // $ANTLR start "REGULAR_EXPR_FIRST_CHAR"
    public final void mREGULAR_EXPR_FIRST_CHAR() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:732:2: (~ ( CR | LF | '*' | '\\\\' | '/' | '>' ) | BACKSLASH_SEQUENCE )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( ((LA11_0>='\u0000' && LA11_0<='\t')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<=')')||(LA11_0>='+' && LA11_0<='.')||(LA11_0>='0' && LA11_0<='=')||(LA11_0>='?' && LA11_0<='[')||(LA11_0>=']' && LA11_0<='\uFFFF')) ) {
                alt11=1;
            }
            else if ( (LA11_0=='\\') ) {
                alt11=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }
            switch (alt11) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:732:4: ~ ( CR | LF | '*' | '\\\\' | '/' | '>' )
                    {
                    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<=')')||(input.LA(1)>='+' && input.LA(1)<='.')||(input.LA(1)>='0' && input.LA(1)<='=')||(input.LA(1)>='?' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                        input.consume();
                    state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;
                case 2 :
                    // com/shin1ogawa/as3/AS3.g:732:35: BACKSLASH_SEQUENCE
                    {
                    mBACKSLASH_SEQUENCE(); if (state.failed) return ;

                    }
                    break;

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

    // $ANTLR start "REGULAR_EXPR_CHAR"
    public final void mREGULAR_EXPR_CHAR() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:736:2: (~ ( CR | LF | '\\\\' | '/' ) | BACKSLASH_SEQUENCE )
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( ((LA12_0>='\u0000' && LA12_0<='\t')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='.')||(LA12_0>='0' && LA12_0<='[')||(LA12_0>=']' && LA12_0<='\uFFFF')) ) {
                alt12=1;
            }
            else if ( (LA12_0=='\\') ) {
                alt12=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }
            switch (alt12) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:736:4: ~ ( CR | LF | '\\\\' | '/' )
                    {
                    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='.')||(input.LA(1)>='0' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
                        input.consume();
                    state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;
                case 2 :
                    // com/shin1ogawa/as3/AS3.g:736:27: BACKSLASH_SEQUENCE
                    {
                    mBACKSLASH_SEQUENCE(); if (state.failed) return ;

                    }
                    break;

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

    // $ANTLR start "BACKSLASH_SEQUENCE"
    public final void mBACKSLASH_SEQUENCE() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:740:2: ( '\\\\' ~ ( CR | LF ) )
            // com/shin1ogawa/as3/AS3.g:740:4: '\\\\' ~ ( CR | LF )
            {
            match('\\'); if (state.failed) return ;
            if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
                input.consume();
            state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

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

    // $ANTLR start "REGULAR_EXPR_FLAG"
    public final void mREGULAR_EXPR_FLAG() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:744:2: ( IDENT_PART )
            // com/shin1ogawa/as3/AS3.g:744:4: IDENT_PART
            {
            mIDENT_PART(); if (state.failed) return ;

            }

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

    // $ANTLR start "HEX_NUMBER_LITERAL"
    public final void mHEX_NUMBER_LITERAL() throws RecognitionException {
        try {
            int _type = HEX_NUMBER_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:751:2: ( '0' ( 'X' | 'x' ) ( HEX_DIGIT )+ )
            // com/shin1ogawa/as3/AS3.g:751:4: '0' ( 'X' | 'x' ) ( HEX_DIGIT )+
            {
            match('0'); if (state.failed) return ;
            if ( input.LA(1)=='X'||input.LA(1)=='x' ) {
                input.consume();
            state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // com/shin1ogawa/as3/AS3.g:751:18: ( HEX_DIGIT )+
            int cnt13=0;
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

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


                switch (alt13) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:751:18: HEX_DIGIT
            	    {
            	    mHEX_DIGIT(); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    if ( cnt13 >= 1 ) break loop13;
            	    if (state.backtracking>0) {state.failed=true; return ;}
                        EarlyExitException eee =
                            new EarlyExitException(13, input);
                        throw eee;
                }
                cnt13++;
            } while (true);


            }

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

    // $ANTLR start "DEC_NUMBER"
    public final void mDEC_NUMBER() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:755:2: ( ( NUMBER )+ '.' ( NUMBER )* | '.' ( NUMBER )+ | ( NUMBER )+ )
            int alt18=3;
            alt18 = dfa18.predict(input);
            switch (alt18) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:755:4: ( NUMBER )+ '.' ( NUMBER )*
                    {
                    // com/shin1ogawa/as3/AS3.g:755:4: ( NUMBER )+
                    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 :
                    	    // com/shin1ogawa/as3/AS3.g:755:4: NUMBER
                    	    {
                    	    mNUMBER(); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt14 >= 1 ) break loop14;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(14, input);
                                throw eee;
                        }
                        cnt14++;
                    } while (true);

                    match('.'); if (state.failed) return ;
                    // com/shin1ogawa/as3/AS3.g:755:16: ( NUMBER )*
                    loop15:
                    do {
                        int alt15=2;
                        int LA15_0 = input.LA(1);

                        if ( ((LA15_0>='0' && LA15_0<='9')) ) {
                            alt15=1;
                        }


                        switch (alt15) {
                    	case 1 :
                    	    // com/shin1ogawa/as3/AS3.g:755:16: NUMBER
                    	    {
                    	    mNUMBER(); if (state.failed) return ;

                    	    }
                    	    break;

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


                    }
                    break;
                case 2 :
                    // com/shin1ogawa/as3/AS3.g:755:26: '.' ( NUMBER )+
                    {
                    match('.'); if (state.failed) return ;
                    // com/shin1ogawa/as3/AS3.g:755:30: ( NUMBER )+
                    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 :
                    	    // com/shin1ogawa/as3/AS3.g:755:30: NUMBER
                    	    {
                    	    mNUMBER(); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt16 >= 1 ) break loop16;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(16, input);
                                throw eee;
                        }
                        cnt16++;
                    } while (true);


                    }
                    break;
                case 3 :
                    // com/shin1ogawa/as3/AS3.g:755:40: ( NUMBER )+
                    {
                    // com/shin1ogawa/as3/AS3.g:755:40: ( NUMBER )+
                    int cnt17=0;
                    loop17:
                    do {
                        int alt17=2;
                        int LA17_0 = input.LA(1);

                        if ( ((LA17_0>='0' && LA17_0<='9')) ) {
                            alt17=1;
                        }


                        switch (alt17) {
                    	case 1 :
                    	    // com/shin1ogawa/as3/AS3.g:755:40: NUMBER
                    	    {
                    	    mNUMBER(); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt17 >= 1 ) break loop17;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(17, input);
                                throw eee;
                        }
                        cnt17++;
                    } while (true);


                    }
                    break;

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

    // $ANTLR start "DEC_NUMBER_LITERAL"
    public final void mDEC_NUMBER_LITERAL() throws RecognitionException {
        try {
            int _type = DEC_NUMBER_LITERAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:759:2: ( DEC_NUMBER ( EXPONENT )? )
            // com/shin1ogawa/as3/AS3.g:759:4: DEC_NUMBER ( EXPONENT )?
            {
            mDEC_NUMBER(); if (state.failed) return ;
            // com/shin1ogawa/as3/AS3.g:759:15: ( EXPONENT )?
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0=='E'||LA19_0=='e') ) {
                alt19=1;
            }
            switch (alt19) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:759:15: EXPONENT
                    {
                    mEXPONENT(); if (state.failed) return ;

                    }
                    break;

            }


            }

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

    // $ANTLR start "EXPONENT"
    public final void mEXPONENT() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:763:2: ( ( 'e' | 'E' ) ( '+' | '-' )? ( NUMBER )+ )
            // com/shin1ogawa/as3/AS3.g:763:4: ( 'e' | 'E' ) ( '+' | '-' )? ( NUMBER )+
            {
            if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
                input.consume();
            state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // com/shin1ogawa/as3/AS3.g:763:14: ( '+' | '-' )?
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0=='+'||LA20_0=='-') ) {
                alt20=1;
            }
            switch (alt20) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:
                    {
                    if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
                        input.consume();
                    state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;

            }

            // com/shin1ogawa/as3/AS3.g:763:25: ( NUMBER )+
            int cnt21=0;
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( ((LA21_0>='0' && LA21_0<='9')) ) {
                    alt21=1;
                }


                switch (alt21) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:763:25: NUMBER
            	    {
            	    mNUMBER(); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    if ( cnt21 >= 1 ) break loop21;
            	    if (state.backtracking>0) {state.failed=true; return ;}
                        EarlyExitException eee =
                            new EarlyExitException(21, input);
                        throw eee;
                }
                cnt21++;
            } while (true);


            }

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

    // $ANTLR start "IDENTIFIER"
    public final void mIDENTIFIER() throws RecognitionException {
        try {
            int _type = IDENTIFIER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:768:2: ( IDENT_NAME_ASCII_START | ( UNICODE_ESCAPE )+ | )
            int alt23=3;
            switch ( input.LA(1) ) {
            case '$':
            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':
            case '_':
            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':
                {
                alt23=1;
                }
                break;
            case '\\':
                {
                alt23=2;
                }
                break;
            default:
                alt23=3;}

            switch (alt23) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:768:4: IDENT_NAME_ASCII_START
                    {
                    mIDENT_NAME_ASCII_START(); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // com/shin1ogawa/as3/AS3.g:768:29: ( UNICODE_ESCAPE )+
                    {
                    // com/shin1ogawa/as3/AS3.g:768:29: ( UNICODE_ESCAPE )+
                    int cnt22=0;
                    loop22:
                    do {
                        int alt22=2;
                        int LA22_0 = input.LA(1);

                        if ( (LA22_0=='\\') ) {
                            alt22=1;
                        }


                        switch (alt22) {
                    	case 1 :
                    	    // com/shin1ogawa/as3/AS3.g:768:29: UNICODE_ESCAPE
                    	    {
                    	    mUNICODE_ESCAPE(); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt22 >= 1 ) break loop22;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(22, input);
                                throw eee;
                        }
                        cnt22++;
                    } while (true);


                    }
                    break;
                case 3 :
                    // com/shin1ogawa/as3/AS3.g:768:47: 
                    {
                    if ( state.backtracking==0 ) {
                      consumeIdentifierUnicodeStart();
                    }

                    }
                    break;

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

    // $ANTLR start "IDENT_NAME_ASCII_START"
    public final void mIDENT_NAME_ASCII_START() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:772:2: ( IDENT_ASCII_START ( IDENT_PART )* )
            // com/shin1ogawa/as3/AS3.g:772:4: IDENT_ASCII_START ( IDENT_PART )*
            {
            mIDENT_ASCII_START(); if (state.failed) return ;
            // com/shin1ogawa/as3/AS3.g:772:22: ( IDENT_PART )*
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( (LA24_0=='$'||(LA24_0>='0' && LA24_0<='9')||(LA24_0>='A' && LA24_0<='Z')||LA24_0=='_'||(LA24_0>='a' && LA24_0<='z')) ) {
                    alt24=1;
                }
                else if ( ((isUnicodeIdentifierPart(input.LA(1)))) ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:772:22: IDENT_PART
            	    {
            	    mIDENT_PART(); if (state.failed) return ;

            	    }
            	    break;

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


            }

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

    // $ANTLR start "IDENT_ASCII_START"
    public final void mIDENT_ASCII_START() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:776:2: ( ALPHABET | DOLLAR | UNDERSCORE )
            // com/shin1ogawa/as3/AS3.g:
            {
            if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();
            state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

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

    // $ANTLR start "IDENT_PART"
    public final void mIDENT_PART() throws RecognitionException {
        try {
            // com/shin1ogawa/as3/AS3.g:780:2: ( ( IDENT_ASCII_START )=> IDENT_ASCII_START | NUMBER | {...}?)
            int alt25=3;
            int LA25_0 = input.LA(1);

            if ( (LA25_0=='$'||(LA25_0>='A' && LA25_0<='Z')||LA25_0=='_'||(LA25_0>='a' && LA25_0<='z')) && (synpred1_AS3())) {
                alt25=1;
            }
            else if ( ((LA25_0>='0' && LA25_0<='9')) ) {
                alt25=2;
            }
            else {
                alt25=3;}
            switch (alt25) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:780:4: ( IDENT_ASCII_START )=> IDENT_ASCII_START
                    {
                    mIDENT_ASCII_START(); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // com/shin1ogawa/as3/AS3.g:780:47: NUMBER
                    {
                    mNUMBER(); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // com/shin1ogawa/as3/AS3.g:780:56: {...}?
                    {
                    if ( !((isUnicodeIdentifierPart(input.LA(1)))) ) {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        throw new FailedPredicateException(input, "IDENT_PART", "isUnicodeIdentifierPart(input.LA(1))");
                    }
                    if ( state.backtracking==0 ) {
                      matchAny();
                    }

                    }
                    break;

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

    // $ANTLR start "XML_COMMENT"
    public final void mXML_COMMENT() throws RecognitionException {
        try {
            int _type = XML_COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:784:2: ( '<!--' ( options {greedy=false; } : . )* '-->' )
            // com/shin1ogawa/as3/AS3.g:784:4: '<!--' ( options {greedy=false; } : . )* '-->'
            {
            match("<!--"); if (state.failed) return ;

            // com/shin1ogawa/as3/AS3.g:784:11: ( options {greedy=false; } : . )*
            loop26:
            do {
                int alt26=2;
                int LA26_0 = input.LA(1);

                if ( (LA26_0=='-') ) {
                    int LA26_1 = input.LA(2);

                    if ( (LA26_1=='-') ) {
                        int LA26_3 = input.LA(3);

                        if ( (LA26_3=='>') ) {
                            alt26=2;
                        }
                        else if ( ((LA26_3>='\u0000' && LA26_3<='=')||(LA26_3>='?' && LA26_3<='\uFFFF')) ) {
                            alt26=1;
                        }


                    }
                    else if ( ((LA26_1>='\u0000' && LA26_1<=',')||(LA26_1>='.' && LA26_1<='\uFFFF')) ) {
                        alt26=1;
                    }


                }
                else if ( ((LA26_0>='\u0000' && LA26_0<=',')||(LA26_0>='.' && LA26_0<='\uFFFF')) ) {
                    alt26=1;
                }


                switch (alt26) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:784:39: .
            	    {
            	    matchAny(); if (state.failed) return ;

            	    }
            	    break;

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

            match("-->"); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_CDATA"
    public final void mXML_CDATA() throws RecognitionException {
        try {
            int _type = XML_CDATA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:788:2: ( '<![CDATA' ( options {greedy=false; } : . )* ']]>' )
            // com/shin1ogawa/as3/AS3.g:788:4: '<![CDATA' ( options {greedy=false; } : . )* ']]>'
            {
            match("<![CDATA"); if (state.failed) return ;

            // com/shin1ogawa/as3/AS3.g:788:15: ( options {greedy=false; } : . )*
            loop27:
            do {
                int alt27=2;
                int LA27_0 = input.LA(1);

                if ( (LA27_0==']') ) {
                    int LA27_1 = input.LA(2);

                    if ( (LA27_1==']') ) {
                        int LA27_3 = input.LA(3);

                        if ( (LA27_3=='>') ) {
                            alt27=2;
                        }
                        else if ( ((LA27_3>='\u0000' && LA27_3<='=')||(LA27_3>='?' && LA27_3<='\uFFFF')) ) {
                            alt27=1;
                        }


                    }
                    else if ( ((LA27_1>='\u0000' && LA27_1<='\\')||(LA27_1>='^' && LA27_1<='\uFFFF')) ) {
                        alt27=1;
                    }


                }
                else if ( ((LA27_0>='\u0000' && LA27_0<='\\')||(LA27_0>='^' && LA27_0<='\uFFFF')) ) {
                    alt27=1;
                }


                switch (alt27) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:788:43: .
            	    {
            	    matchAny(); if (state.failed) return ;

            	    }
            	    break;

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

            match("]]>"); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_PI"
    public final void mXML_PI() throws RecognitionException {
        try {
            int _type = XML_PI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:792:2: ( '<?' ( options {greedy=false; } : . )* '?>' )
            // com/shin1ogawa/as3/AS3.g:792:4: '<?' ( options {greedy=false; } : . )* '?>'
            {
            match("<?"); if (state.failed) return ;

            // com/shin1ogawa/as3/AS3.g:792:9: ( options {greedy=false; } : . )*
            loop28:
            do {
                int alt28=2;
                int LA28_0 = input.LA(1);

                if ( (LA28_0=='?') ) {
                    int LA28_1 = input.LA(2);

                    if ( (LA28_1=='>') ) {
                        alt28=2;
                    }
                    else if ( ((LA28_1>='\u0000' && LA28_1<='=')||(LA28_1>='?' && LA28_1<='\uFFFF')) ) {
                        alt28=1;
                    }


                }
                else if ( ((LA28_0>='\u0000' && LA28_0<='>')||(LA28_0>='@' && LA28_0<='\uFFFF')) ) {
                    alt28=1;
                }


                switch (alt28) {
            	case 1 :
            	    // com/shin1ogawa/as3/AS3.g:792:37: .
            	    {
            	    matchAny(); if (state.failed) return ;

            	    }
            	    break;

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

            match("?>"); if (state.failed) return ;


            }

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

    // $ANTLR start "XML_TEXT"
    public final void mXML_TEXT() throws RecognitionException {
        try {
            int _type = XML_TEXT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/shin1ogawa/as3/AS3.g:797:2: ( '\\u0020' .. '\\u003b' | '\\u003d' .. '\\u007a' | '\\u007c' .. '\\u007e' | {...}?)
            int alt29=4;
            switch ( input.LA(1) ) {
            case ' ':
            case '!':
            case '\"':
            case '#':
            case '$':
            case '%':
            case '&':
            case '\'':
            case '(':
            case ')':
            case '*':
            case '+':
            case ',':
            case '-':
            case '.':
            case '/':
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            case ':':
            case ';':
                {
                alt29=1;
                }
                break;
            case '=':
            case '>':
            case '?':
            case '@':
            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':
            case '[':
            case '\\':
            case ']':
            case '^':
            case '_':
            case '`':
            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':
                {
                alt29=2;
                }
                break;
            case '|':
            case '}':
            case '~':
                {
                alt29=3;
                }
                break;
            default:
                alt29=4;}

            switch (alt29) {
                case 1 :
                    // com/shin1ogawa/as3/AS3.g:797:4: '\\u0020' .. '\\u003b'
                    {
                    matchRange(' ',';'); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // com/shin1ogawa/as3/AS3.g:797:25: '\\u003d' .. '\\u007a'
                    {
                    matchRange('=','z'); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // com/shin1ogawa/as3/AS3.g:797:46: '\\u007c' .. '\\u007e'
                    {
                    matchRange('|','~'); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // com/shin1ogawa/as3/AS3.g:797:67: {...}?
                    {
                    if ( !((isXMLText(input.LA(1)))) ) {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        throw new FailedPredicateException(input, "XML_TEXT", "isXMLText(input.LA(1))");
                    }
                    if ( state.backtracking==0 ) {
                      matchAny();
                    }

                    }
                    break;

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

    public void mTokens() throws RecognitionException {
        // com/shin1ogawa/as3/AS3.g:1:8: ( AS | BREAK | CASE | CATCH | CLASS | CONST | CONTINUE | DEFAULT | DELETE | DO | ELSE | EXTENDS | FALSE | FINALLY | FOR | FUNCTION | IF | IMPLEMENTS | IMPORT | IN | INSTANCEOF | INTERFACE | INTERNAL | IS | NATIVE | NEW | NULL | PACKAGE | PRIVATE | PROTECTED | PUBLIC | RETURN | SUPER | SWITCH | THIS | THROW | TO | TRUE | TRY | TYPEOF | USE | VAR | VOID | WHILE | WITH | EACH | GET | SET | NAMESPACE | INCLUDE | DYNAMIC | FINAL | OVERRIDE | STATIC | SEMI | LCURLY | RCURLY | LPAREN | RPAREN | LBRACK | RBRACK | DOT | COMMA | LT | GT | LTE | EQ | NEQ | SAME | NSAME | PLUS | SUB | STAR | DIV | MOD | INC | DEC | SHL | SHR | SHU | AND | OR | XOR | NOT | INV | LAND | LOR | QUE | COLON | ASSIGN | UNDERSCORE | DOLLAR | MUL_ASSIGN | DIV_ASSIGN | MOD_ASSIGN | ADD_ASSIGN | SUB_ASSIGN | SHL_ASSIGN | SHR_ASSIGN | SHU_ASSIGN | AND_ASSIGN | XOR_ASSIGN | OR_ASSIGN | ELLIPSIS | XML_ELLIPSIS | XML_TEND | XML_E_TEND | XML_NS_OP | XML_AT | XML_LS_STD | XML_LS_END | EOL | WHITESPACE | COMMENT_MULTILINE | COMMENT_SINGLELINE | SINGLE_QUOTE_LITERAL | DOUBLE_QUOTE_LITERAL | REGULAR_EXPR_LITERAL | HEX_NUMBER_LITERAL | DEC_NUMBER_LITERAL | IDENTIFIER | XML_COMMENT | XML_CDATA | XML_PI | XML_TEXT )
        int alt30=125;
        alt30 = dfa30.predict(input);
        switch (alt30) {
            case 1 :
                // com/shin1ogawa/as3/AS3.g:1:10: AS
                {
                mAS(); if (state.failed) return ;

                }
                break;
            case 2 :
                // com/shin1ogawa/as3/AS3.g:1:13: BREAK
                {
                mBREAK(); if (state.failed) return ;

                }
                break;
            case 3 :
                // com/shin1ogawa/as3/AS3.g:1:19: CASE
                {
                mCASE(); if (state.failed) return ;

                }
                break;
            case 4 :
                // com/shin1ogawa/as3/AS3.g:1:24: CATCH
                {
                mCATCH(); if (state.failed) return ;

                }
                break;
            case 5 :
                // com/shin1ogawa/as3/AS3.g:1:30: CLASS
                {
                mCLASS(); if (state.failed) return ;

                }
                break;
            case 6 :
                // com/shin1ogawa/as3/AS3.g:1:36: CONST
                {
                mCONST(); if (state.failed) return ;

                }
                break;
            case 7 :
                // com/shin1ogawa/as3/AS3.g:1:42: CONTINUE
                {
                mCONTINUE(); if (state.failed) return ;

                }
                break;
            case 8 :
                // com/shin1ogawa/as3/AS3.g:1:51: DEFAULT
                {
                mDEFAULT(); if (state.failed) return ;

                }
                break;
            case 9 :
                // com/shin1ogawa/as3/AS3.g:1:59: DELETE
                {
                mDELETE(); if (state.failed) return ;

                }
                break;
            case 10 :
                // com/shin1ogawa/as3/AS3.g:1:66: DO
                {
                mDO(); if (state.failed) return ;

                }
                break;
            case 11 :
                // com/shin1ogawa/as3/AS3.g:1:69: ELSE
                {
                mELSE(); if (state.failed) return ;

                }
                break;
            case 12 :
                // com/shin1ogawa/as3/AS3.g:1:74: EXTENDS
                {
                mEXTENDS(); if (state.failed) return ;

                }
                break;
            case 13 :
                // com/shin1ogawa/as3/AS3.g:1:82: FALSE
                {
                mFALSE(); if (state.failed) return ;

                }
                break;
            case 14 :
                // com/shin1ogawa/as3/AS3.g:1:88: FINALLY
                {
                mFINALLY(); if (state.failed) return ;

                }
                break;
            case 15 :
                // com/shin1ogawa/as3/AS3.g:1:96: FOR
                {
                mFOR(); if (state.failed) return ;

                }
                break;
            case 16 :
                // com/shin1ogawa/as3/AS3.g:1:100: FUNCTION
                {
                mFUNCTION(); if (state.failed) return ;

                }
                break;
            case 17 :
                // com/shin1ogawa/as3/AS3.g:1:109: IF
                {
                mIF(); if (state.failed) return ;

                }
                break;
            case 18 :
                // com/shin1ogawa/as3/AS3.g:1:112: IMPLEMENTS
                {
                mIMPLEMENTS(); if (state.failed) return ;

                }
                break;
            case 19 :
                // com/shin1ogawa/as3/AS3.g:1:123: IMPORT
                {
                mIMPORT(); if (state.failed) return ;

                }
                break;
            case 20 :
                // com/shin1ogawa/as3/AS3.g:1:130: IN
                {
                mIN(); if (state.failed) return ;

                }
                break;
            case 21 :
                // com/shin1ogawa/as3/AS3.g:1:133: INSTANCEOF
                {
                mINSTANCEOF(); if (state.failed) return ;

                }
                break;
            case 22 :
                // com/shin1ogawa/as3/AS3.g:1:144: INTERFACE
                {
                mINTERFACE(); if (state.failed) return ;

                }
                break;
            case 23 :
                // com/shin1ogawa/as3/AS3.g:1:154: INTERNAL
                {
                mINTERNAL(); if (state.failed) return ;

                }
                break;
            case 24 :
                // com/shin1ogawa/as3/AS3.g:1:163: IS
                {
                mIS(); if (state.failed) return ;

                }
                break;
            case 25 :
                // com/shin1ogawa/as3/AS3.g:1:166: NATIVE
                {
                mNATIVE(); if (state.failed) return ;

                }
                break;
            case 26 :
                // com/shin1ogawa/as3/AS3.g:1:173: NEW
                {
                mNEW(); if (state.failed) return ;

                }
                break;
            case 27 :
                // com/shin1ogawa/as3/AS3.g:1:177: NULL
                {
                mNULL(); if (state.failed) return ;

                }
                break;
            case 28 :
                // com/shin1ogawa/as3/AS3.g:1:182: PACKAGE
                {
                mPACKAGE(); if (state.failed) return ;

                }
                break;
            case 29 :
                // com/shin1ogawa/as3/AS3.g:1:190: PRIVATE
                {
                mPRIVATE(); if (state.failed) return ;

                }
                break;
            case 30 :
                // com/shin1ogawa/as3/AS3.g:1:198: PROTECTED
                {
                mPROTECTED(); if (state.failed) return ;

                }
                break;
            case 31 :
                // com/shin1ogawa/as3/AS3.g:1:208: PUBLIC
                {
                mPUBLIC(); if (state.failed) return ;

                }
                break;
            case 32 :
                // com/shin1ogawa/as3/AS3.g:1:215: RETURN
                {
                mRETURN(); if (state.failed) return ;

                }
                break;
            case 33 :
                // com/shin1ogawa/as3/AS3.g:1:222: SUPER
                {
                mSUPER(); if (state.failed) return ;

                }
                break;
            case 34 :
                // com/shin1ogawa/as3/AS3.g:1:228: SWITCH
                {
                mSWITCH(); if (state.failed) return ;

                }
                break;
            case 35 :
                // com/shin1ogawa/as3/AS3.g:1:235: THIS
                {
                mTHIS(); if (state.failed) return ;

                }
                break;
            case 36 :
                // com/shin1ogawa/as3/AS3.g:1:240: THROW
                {
                mTHROW(); if (state.failed) return ;

                }
                break;
            case 37 :
                // com/shin1ogawa/as3/AS3.g:1:246: TO
                {
                mTO(); if (state.failed) return ;

                }
                break;
            case 38 :
                // com/shin1ogawa/as3/AS3.g:1:249: TRUE
                {
                mTRUE(); if (state.failed) return ;

                }
                break;
            case 39 :
                // com/shin1ogawa/as3/AS3.g:1:254: TRY
                {
                mTRY(); if (state.failed) return ;

                }
                break;
            case 40 :
                // com/shin1ogawa/as3/AS3.g:1:258: TYPEOF
                {
                mTYPEOF(); if (state.failed) return ;

                }
                break;
            case 41 :
                // com/shin1ogawa/as3/AS3.g:1:265: USE
                {
                mUSE(); if (state.failed) return ;

                }
                break;
            case 42 :
                // com/shin1ogawa/as3/AS3.g:1:269: VAR
                {
                mVAR(); if (state.failed) return ;

                }
                break;
            case 43 :
                // com/shin1ogawa/as3/AS3.g:1:273: VOID
                {
                mVOID(); if (state.failed) return ;

                }
                break;
            case 44 :
                // com/shin1ogawa/as3/AS3.g:1:278: WHILE
                {
                mWHILE(); if (state.failed) return ;

                }
                break;
            case 45 :
                // com/shin1ogawa/as3/AS3.g:1:284: WITH
                {
                mWITH(); if (state.failed) return ;

                }
                break;
            case 46 :
                // com/shin1ogawa/as3/AS3.g:1:289: EACH
                {
                mEACH(); if (state.failed) return ;

                }
                break;
            case 47 :
                // com/shin1ogawa/as3/AS3.g:1:294: GET
                {
                mGET(); if (state.failed) return ;

                }
                break;
            case 48 :
                // com/shin1ogawa/as3/AS3.g:1:298: SET
                {
                mSET(); if (state.failed) return ;

                }
                break;
            case 49 :
                // com/shin1ogawa/as3/AS3.g:1:302: NAMESPACE
                {
                mNAMESPACE(); if (state.failed) return ;

                }
                break;
            case 50 :
                // com/shin1ogawa/as3/AS3.g:1:312: INCLUDE
                {
                mINCLUDE(); if (state.failed) return ;

                }
                break;
            case 51 :
                // com/shin1ogawa/as3/AS3.g:1:320: DYNAMIC
                {
                mDYNAMIC(); if (state.failed) return ;

                }
                break;
            case 52 :
                // com/shin1ogawa/as3/AS3.g:1:328: FINAL
                {
                mFINAL(); if (state.failed) return ;

                }
                break;
            case 53 :
                // com/shin1ogawa/as3/AS3.g:1:334: OVERRIDE
                {
                mOVERRIDE(); if (state.failed) return ;

                }
                break;
            case 54 :
                // com/shin1ogawa/as3/AS3.g:1:343: STATIC
                {
                mSTATIC(); if (state.failed) return ;

                }
                break;
            case 55 :
                // com/shin1ogawa/as3/AS3.g:1:350: SEMI
                {
                mSEMI(); if (state.failed) return ;

                }
                break;
            case 56 :
                // com/shin1ogawa/as3/AS3.g:1:355: LCURLY
                {
                mLCURLY(); if (state.failed) return ;

                }
                break;
            case 57 :
                // com/shin1ogawa/as3/AS3.g:1:362: RCURLY
                {
                mRCURLY(); if (state.failed) return ;

                }
                break;
            case 58 :
                // com/shin1ogawa/as3/AS3.g:1:369: LPAREN
                {
                mLPAREN(); if (state.failed) return ;

                }
                break;
            case 59 :
                // com/shin1ogawa/as3/AS3.g:1:376: RPAREN
                {
                mRPAREN(); if (state.failed) return ;

                }
                break;
            case 60 :
                // com/shin1ogawa/as3/AS3.g:1:383: LBRACK
                {
                mLBRACK(); if (state.failed) return ;

                }
                break;
            case 61 :
                // com/shin1ogawa/as3/AS3.g:1:390: RBRACK
                {
                mRBRACK(); if (state.failed) return ;

                }
                break;
            case 62 :
                // com/shin1ogawa/as3/AS3.g:1:397: DOT
                {
                mDOT(); if (state.failed) return ;

                }
                break;
            case 63 :
                // com/shin1ogawa/as3/AS3.g:1:401: COMMA
                {
                mCOMMA(); if (state.failed) return ;

                }
                break;
            case 64 :
                // com/shin1ogawa/as3/AS3.g:1:407: LT
                {
                mLT(); if (state.failed) return ;

                }
                break;
            case 65 :
                // com/shin1ogawa/as3/AS3.g:1:410: GT
                {
                mGT(); if (state.failed) return ;

                }
                break;
            case 66 :
                // com/shin1ogawa/as3/AS3.g:1:413: LTE
                {
                mLTE(); if (state.failed) return ;

                }
                break;
            case 67 :
                // com/shin1ogawa/as3/AS3.g:1:417: EQ
                {
                mEQ(); if (state.failed) return ;

                }
                break;
            case 68 :
                // com/shin1ogawa/as3/AS3.g:1:420: NEQ
                {
                mNEQ(); if (state.failed) return ;

                }
                break;
            case 69 :
                // com/shin1ogawa/as3/AS3.g:1:424: SAME
                {
                mSAME(); if (state.failed) return ;

                }
                break;
            case 70 :
                // com/shin1ogawa/as3/AS3.g:1:429: NSAME
                {
                mNSAME(); if (state.failed) return ;

                }
                break;
            case 71 :
                // com/shin1ogawa/as3/AS3.g:1:435: PLUS
                {
                mPLUS(); if (state.failed) return ;

                }
                break;
            case 72 :
                // com/shin1ogawa/as3/AS3.g:1:440: SUB
                {
                mSUB(); if (state.failed) return ;

                }
                break;
            case 73 :
                // com/shin1ogawa/as3/AS3.g:1:444: STAR
                {
                mSTAR(); if (state.failed) return ;

                }
                break;
            case 74 :
                // com/shin1ogawa/as3/AS3.g:1:449: DIV
                {
                mDIV(); if (state.failed) return ;

                }
                break;
            case 75 :
                // com/shin1ogawa/as3/AS3.g:1:453: MOD
                {
                mMOD(); if (state.failed) return ;

                }
                break;
            case 76 :
                // com/shin1ogawa/as3/AS3.g:1:457: INC
                {
                mINC(); if (state.failed) return ;

                }
                break;
            case 77 :
                // com/shin1ogawa/as3/AS3.g:1:461: DEC
                {
                mDEC(); if (state.failed) return ;

                }
                break;
            case 78 :
                // com/shin1ogawa/as3/AS3.g:1:465: SHL
                {
                mSHL(); if (state.failed) return ;

                }
                break;
            case 79 :
                // com/shin1ogawa/as3/AS3.g:1:469: SHR
                {
                mSHR(); if (state.failed) return ;

                }
                break;
            case 80 :
                // com/shin1ogawa/as3/AS3.g:1:473: SHU
                {
                mSHU(); if (state.failed) return ;

                }
                break;
            case 81 :
                // com/shin1ogawa/as3/AS3.g:1:477: AND
                {
                mAND(); if (state.failed) return ;

                }
                break;
            case 82 :
                // com/shin1ogawa/as3/AS3.g:1:481: OR
                {
                mOR(); if (state.failed) return ;

                }
                break;
            case 83 :
                // com/shin1ogawa/as3/AS3.g:1:484: XOR
                {
                mXOR(); if (state.failed) return ;

                }
                break;
            case 84 :
                // com/shin1ogawa/as3/AS3.g:1:488: NOT
                {
                mNOT(); if (state.failed) return ;

                }
                break;
            case 85 :
                // com/shin1ogawa/as3/AS3.g:1:492: INV
                {
                mINV(); if (state.failed) return ;

                }
                break;
            case 86 :
                // com/shin1ogawa/as3/AS3.g:1:496: LAND
                {
                mLAND(); if (state.failed) return ;

                }
                break;
            case 87 :
                // com/shin1ogawa/as3/AS3.g:1:501: LOR
                {
                mLOR(); if (state.failed) return ;

                }
                break;
            case 88 :
                // com/shin1ogawa/as3/AS3.g:1:505: QUE
                {
                mQUE(); if (state.failed) return ;

                }
                break;
            case 89 :
                // com/shin1ogawa/as3/AS3.g:1:509: COLON
                {
                mCOLON(); if (state.failed) return ;

                }
                break;
            case 90 :
                // com/shin1ogawa/as3/AS3.g:1:515: ASSIGN
                {
                mASSIGN(); if (state.failed) return ;

                }
                break;
            case 91 :
                // com/shin1ogawa/as3/AS3.g:1:522: UNDERSCORE
                {
                mUNDERSCORE(); if (state.failed) return ;

                }
                break;
            case 92 :
                // com/shin1ogawa/as3/AS3.g:1:533: DOLLAR
                {
                mDOLLAR(); if (state.failed) return ;

                }
                break;
            case 93 :
                // com/shin1ogawa/as3/AS3.g:1:540: MUL_ASSIGN
                {
                mMUL_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 94 :
                // com/shin1ogawa/as3/AS3.g:1:551: DIV_ASSIGN
                {
                mDIV_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 95 :
                // com/shin1ogawa/as3/AS3.g:1:562: MOD_ASSIGN
                {
                mMOD_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 96 :
                // com/shin1ogawa/as3/AS3.g:1:573: ADD_ASSIGN
                {
                mADD_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 97 :
                // com/shin1ogawa/as3/AS3.g:1:584: SUB_ASSIGN
                {
                mSUB_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 98 :
                // com/shin1ogawa/as3/AS3.g:1:595: SHL_ASSIGN
                {
                mSHL_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 99 :
                // com/shin1ogawa/as3/AS3.g:1:606: SHR_ASSIGN
                {
                mSHR_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 100 :
                // com/shin1ogawa/as3/AS3.g:1:617: SHU_ASSIGN
                {
                mSHU_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 101 :
                // com/shin1ogawa/as3/AS3.g:1:628: AND_ASSIGN
                {
                mAND_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 102 :
                // com/shin1ogawa/as3/AS3.g:1:639: XOR_ASSIGN
                {
                mXOR_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 103 :
                // com/shin1ogawa/as3/AS3.g:1:650: OR_ASSIGN
                {
                mOR_ASSIGN(); if (state.failed) return ;

                }
                break;
            case 104 :
                // com/shin1ogawa/as3/AS3.g:1:660: ELLIPSIS
                {
                mELLIPSIS(); if (state.failed) return ;

                }
                break;
            case 105 :
                // com/shin1ogawa/as3/AS3.g:1:669: XML_ELLIPSIS
                {
                mXML_ELLIPSIS(); if (state.failed) return ;

                }
                break;
            case 106 :
                // com/shin1ogawa/as3/AS3.g:1:682: XML_TEND
                {
                mXML_TEND(); if (state.failed) return ;

                }
                break;
            case 107 :
                // com/shin1ogawa/as3/AS3.g:1:691: XML_E_TEND
                {
                mXML_E_TEND(); if (state.failed) return ;

                }
                break;
            case 108 :
                // com/shin1ogawa/as3/AS3.g:1:702: XML_NS_OP
                {
                mXML_NS_OP(); if (state.failed) return ;

                }
                break;
            case 109 :
                // com/shin1ogawa/as3/AS3.g:1:712: XML_AT
                {
                mXML_AT(); if (state.failed) return ;

                }
                break;
            case 110 :
                // com/shin1ogawa/as3/AS3.g:1:719: XML_LS_STD
                {
                mXML_LS_STD(); if (state.failed) return ;

                }
                break;
            case 111 :
                // com/shin1ogawa/as3/AS3.g:1:730: XML_LS_END
                {
                mXML_LS_END(); if (state.failed) return ;

                }
                break;
            case 112 :
                // com/shin1ogawa/as3/AS3.g:1:741: EOL
                {
                mEOL(); if (state.failed) return ;

                }
                break;
            case 113 :
                // com/shin1ogawa/as3/AS3.g:1:745: WHITESPACE
                {
                mWHITESPACE(); if (state.failed) return ;

                }
                break;
            case 114 :
                // com/shin1ogawa/as3/AS3.g:1:756: COMMENT_MULTILINE
                {
                mCOMMENT_MULTILINE(); if (state.failed) return ;

                }
                break;
            case 115 :
                // com/shin1ogawa/as3/AS3.g:1:774: COMMENT_SINGLELINE
                {
                mCOMMENT_SINGLELINE(); if (state.failed) return ;

                }
                break;
            case 116 :
                // com/shin1ogawa/as3/AS3.g:1:793: SINGLE_QUOTE_LITERAL
                {
                mSINGLE_QUOTE_LITERAL(); if (state.failed) return ;

                }
                break;
            case 117 :
                // com/shin1ogawa/as3/AS3.g:1:814: DOUBLE_QUOTE_LITERAL
                {
                mDOUBLE_QUOTE_LITERAL(); if (state.failed) return ;

                }
                break;
            case 118 :
                // com/shin1ogawa/as3/AS3.g:1:835: REGULAR_EXPR_LITERAL
                {
                mREGULAR_EXPR_LITERAL(); if (state.failed) return ;

                }
                break;
            case 119 :
                // com/shin1ogawa/as3/AS3.g:1:856: HEX_NUMBER_LITERAL
                {
                mHEX_NUMBER_LITERAL(); if (state.failed) return ;

                }
                break;
            case 120 :
                // com/shin1ogawa/as3/AS3.g:1:875: DEC_NUMBER_LITERAL
                {
                mDEC_NUMBER_LITERAL(); if (state.failed) return ;

                }
                break;
            case 121 :
                // com/shin1ogawa/as3/AS3.g:1:894: IDENTIFIER
                {
                mIDENTIFIER(); if (state.failed) return ;

                }
                break;
            case 122 :
                // com/shin1ogawa/as3/AS3.g:1:905: XML_COMMENT
                {
                mXML_COMMENT(); if (state.failed) return ;

                }
                break;
            case 123 :
                // com/shin1ogawa/as3/AS3.g:1:917: XML_CDATA
                {
                mXML_CDATA(); if (state.failed) return ;

                }
                break;
            case 124 :
                // com/shin1ogawa/as3/AS3.g:1:927: XML_PI
                {
                mXML_PI(); if (state.failed) return ;

                }
                break;
            case 125 :
                // com/shin1ogawa/as3/AS3.g:1:934: XML_TEXT
                {
                mXML_TEXT(); if (state.failed) return ;

                }
                break;

        }

    }

    // $ANTLR start synpred1_AS3
    public final void synpred1_AS3_fragment() throws RecognitionException {   
        // com/shin1ogawa/as3/AS3.g:780:4: ( IDENT_ASCII_START )
        // com/shin1ogawa/as3/AS3.g:780:5: IDENT_ASCII_START
        {
        mIDENT_ASCII_START(); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred1_AS3

    public final boolean synpred1_AS3() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred1_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA18 dfa18 = new DFA18(this);
    protected DFA30 dfa30 = new DFA30(this);
    static final String DFA18_eotS =
        "\1\uffff\1\3\3\uffff";
    static final String DFA18_eofS =
        "\5\uffff";
    static final String DFA18_minS =
        "\2\56\3\uffff";
    static final String DFA18_maxS =
        "\2\71\3\uffff";
    static final String DFA18_acceptS =
        "\2\uffff\1\2\1\3\1\1";
    static final String DFA18_specialS =
        "\5\uffff}>";
    static final String[] DFA18_transitionS = {
            "\1\2\1\uffff\12\1",
            "\1\4\1\uffff\12\1",
            "",
            "",
            ""
    };

    static final short[] DFA18_eot = DFA.unpackEncodedString(DFA18_eotS);
    static final short[] DFA18_eof = DFA.unpackEncodedString(DFA18_eofS);
    static final char[] DFA18_min = DFA.unpackEncodedStringToUnsignedChars(DFA18_minS);
    static final char[] DFA18_max = DFA.unpackEncodedStringToUnsignedChars(DFA18_maxS);
    static final short[] DFA18_accept = DFA.unpackEncodedString(DFA18_acceptS);
    static final short[] DFA18_special = DFA.unpackEncodedString(DFA18_specialS);
    static final short[][] DFA18_transition;

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

    class DFA18 extends DFA {

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

    static final short[] DFA30_eot = DFA.unpackEncodedString(DFA30_eotS);
    static final short[] DFA30_eof = DFA.unpackEncodedString(DFA30_eofS);
    static final char[] DFA30_min = DFA.unpackEncodedStringToUnsignedChars(DFA30_minS);
    static final char[] DFA30_max = DFA.unpackEncodedStringToUnsignedChars(DFA30_maxS);
    static final short[] DFA30_accept = DFA.unpackEncodedString(DFA30_acceptS);
    static final short[] DFA30_special = DFA.unpackEncodedString(DFA30_specialS);
    static final short[][] DFA30_transition;

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

    class DFA30 extends DFA {

        public DFA30(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 30;
            this.eot = DFA30_eot;
            this.eof = DFA30_eof;
            this.min = DFA30_min;
            this.max = DFA30_max;
            this.accept = DFA30_accept;
            this.special = DFA30_special;
            this.transition = DFA30_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( AS | BREAK | CASE | CATCH | CLASS | CONST | CONTINUE | DEFAULT | DELETE | DO | ELSE | EXTENDS | FALSE | FINALLY | FOR | FUNCTION | IF | IMPLEMENTS | IMPORT | IN | INSTANCEOF | INTERFACE | INTERNAL | IS | NATIVE | NEW | NULL | PACKAGE | PRIVATE | PROTECTED | PUBLIC | RETURN | SUPER | SWITCH | THIS | THROW | TO | TRUE | TRY | TYPEOF | USE | VAR | VOID | WHILE | WITH | EACH | GET | SET | NAMESPACE | INCLUDE | DYNAMIC | FINAL | OVERRIDE | STATIC | SEMI | LCURLY | RCURLY | LPAREN | RPAREN | LBRACK | RBRACK | DOT | COMMA | LT | GT | LTE | EQ | NEQ | SAME | NSAME | PLUS | SUB | STAR | DIV | MOD | INC | DEC | SHL | SHR | SHU | AND | OR | XOR | NOT | INV | LAND | LOR | QUE | COLON | ASSIGN | UNDERSCORE | DOLLAR | MUL_ASSIGN | DIV_ASSIGN | MOD_ASSIGN | ADD_ASSIGN | SUB_ASSIGN | SHL_ASSIGN | SHR_ASSIGN | SHU_ASSIGN | AND_ASSIGN | XOR_ASSIGN | OR_ASSIGN | ELLIPSIS | XML_ELLIPSIS | XML_TEND | XML_E_TEND | XML_NS_OP | XML_AT | XML_LS_STD | XML_LS_END | EOL | WHITESPACE | COMMENT_MULTILINE | COMMENT_SINGLELINE | SINGLE_QUOTE_LITERAL | DOUBLE_QUOTE_LITERAL | REGULAR_EXPR_LITERAL | HEX_NUMBER_LITERAL | DEC_NUMBER_LITERAL | IDENTIFIER | XML_COMMENT | XML_CDATA | XML_PI | XML_TEXT );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA30_129 = input.LA(1);

                         
                        int index30_129 = input.index();
                        input.rewind();
                        s = -1;
                        if ( ((LA30_129>='\u0000' && LA30_129<='\t')||(LA30_129>='\u000B' && LA30_129<='\f')||(LA30_129>='\u000E' && LA30_129<='\uFFFF')) && ((isRegularExpression()))) {s = 134;}

                        else s = 220;

                         
                        input.seek(index30_129);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA30_34 = input.LA(1);

                         
                        int index30_34 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (LA30_34=='=') ) {s = 129;}

                        else if ( (LA30_34=='>') ) {s = 130;}

                        else if ( (LA30_34=='*') ) {s = 131;}

                        else if ( (LA30_34=='/') ) {s = 132;}

                        else if ( ((LA30_34>='\u0000' && LA30_34<='\t')||(LA30_34>='\u000B' && LA30_34<='\f')||(LA30_34>='\u000E' && LA30_34<=')')||(LA30_34>='+' && LA30_34<='.')||(LA30_34>='0' && LA30_34<='<')||(LA30_34>='?' && LA30_34<='\uFFFF')) && ((isRegularExpression()))) {s = 134;}

                        else s = 133;

                         
                        input.seek(index30_34);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA30_48 = input.LA(1);

                        s = -1;
                        if ( ((LA30_48>='\u0000' && LA30_48<='\uFFFF')) ) {s = 152;}

                        else s = 55;

                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA30_54 = input.LA(1);

                         
                        int index30_54 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (!(((isXMLText(input.LA(1)))))) ) {s = 57;}

                        else if ( ((isXMLText(input.LA(1)))) ) {s = 55;}

                         
                        input.seek(index30_54);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA30_49 = input.LA(1);

                        s = -1;
                        if ( ((LA30_49>='\u0000' && LA30_49<='\uFFFF')) ) {s = 153;}

                        else s = 55;

                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 30, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

}