Java_MITLexer.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     ANTLR Version: 3.5.1
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

// $ANTLR 3.5.1 G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g 2015-04-17 18:34:13

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
// Missing XML comment for publicly visible type or member 'Type_or_Member'
#pragma warning disable 1591

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using Antlr.Runtime;
using Antlr.Runtime.Misc;
using ConditionalAttribute = System.Diagnostics.ConditionalAttribute;

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.5.1")]
[System.CLSCompliant(false)]
public partial class Java_MITLexer : Antlr.Runtime.Lexer
{
	public const int EOF=-1;
	public const int T__26=26;
	public const int T__27=27;
	public const int T__28=28;
	public const int T__29=29;
	public const int T__30=30;
	public const int T__31=31;
	public const int T__32=32;
	public const int T__33=33;
	public const int T__34=34;
	public const int T__35=35;
	public const int T__36=36;
	public const int T__37=37;
	public const int T__38=38;
	public const int T__39=39;
	public const int T__40=40;
	public const int T__41=41;
	public const int T__42=42;
	public const int T__43=43;
	public const int T__44=44;
	public const int T__45=45;
	public const int T__46=46;
	public const int T__47=47;
	public const int T__48=48;
	public const int T__49=49;
	public const int T__50=50;
	public const int T__51=51;
	public const int T__52=52;
	public const int T__53=53;
	public const int T__54=54;
	public const int T__55=55;
	public const int T__56=56;
	public const int T__57=57;
	public const int T__58=58;
	public const int T__59=59;
	public const int T__60=60;
	public const int T__61=61;
	public const int T__62=62;
	public const int T__63=63;
	public const int T__64=64;
	public const int T__65=65;
	public const int T__66=66;
	public const int T__67=67;
	public const int T__68=68;
	public const int T__69=69;
	public const int T__70=70;
	public const int T__71=71;
	public const int T__72=72;
	public const int T__73=73;
	public const int T__74=74;
	public const int T__75=75;
	public const int T__76=76;
	public const int T__77=77;
	public const int T__78=78;
	public const int T__79=79;
	public const int T__80=80;
	public const int T__81=81;
	public const int T__82=82;
	public const int T__83=83;
	public const int T__84=84;
	public const int T__85=85;
	public const int T__86=86;
	public const int T__87=87;
	public const int T__88=88;
	public const int T__89=89;
	public const int T__90=90;
	public const int T__91=91;
	public const int T__92=92;
	public const int T__93=93;
	public const int T__94=94;
	public const int T__95=95;
	public const int T__96=96;
	public const int T__97=97;
	public const int T__98=98;
	public const int T__99=99;
	public const int T__100=100;
	public const int T__101=101;
	public const int T__102=102;
	public const int T__103=103;
	public const int T__104=104;
	public const int T__105=105;
	public const int T__106=106;
	public const int T__107=107;
	public const int T__108=108;
	public const int T__109=109;
	public const int T__110=110;
	public const int T__111=111;
	public const int T__112=112;
	public const int T__113=113;
	public const int T__114=114;
	public const int ASSERT=4;
	public const int COMMENT=5;
	public const int CharacterLiteral=6;
	public const int Comments=7;
	public const int DecimalLiteral=8;
	public const int ENUM=9;
	public const int EscapeSequence=10;
	public const int Exponent=11;
	public const int FloatTypeSuffix=12;
	public const int FloatingPointLiteral=13;
	public const int HexDigit=14;
	public const int HexLiteral=15;
	public const int Identifier=16;
	public const int IntegerTypeSuffix=17;
	public const int JavaIDDigit=18;
	public const int LINE_COMMENT=19;
	public const int Letter=20;
	public const int OctalEscape=21;
	public const int OctalLiteral=22;
	public const int StringLiteral=23;
	public const int UnicodeEscape=24;
	public const int WS=25;

		protected bool enumIsKeyword = true;
		protected bool assertIsKeyword = true;
		
		// Data fields
		public int charCount = 0;
		public int whiteSpaceCount = 0;
		public int commentCharCount = 0;

		public List<String> commentsSet = new List<String>();
		
		// Data accessors
		public int getCharCount()
		{
			//int commentChars = 0;
	                for (int k = 0; k < commentsSet.Count; k++ )
	                {
	                    String com = commentsSet.ElementAt(k).ToString();
	                    commentCharCount += com.Length;
	                }
	                return commentCharCount; 
		}
		public int getWhiteSpaceCount(){ return whiteSpaceCount; }
		public int getCommentCharCount(){ return commentCharCount; }


    // delegates
    // delegators

	public Java_MITLexer()
	{
		OnCreated();
	}

	public Java_MITLexer(ICharStream input )
		: this(input, new RecognizerSharedState())
	{
	}

	public Java_MITLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state)
	{

		OnCreated();
	}
	public override string GrammarFileName { get { return "G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g"; } }

	private static readonly bool[] decisionCanBacktrack = new bool[0];

	[Conditional("ANTLR_TRACE")]
	protected virtual void OnCreated() {}
	[Conditional("ANTLR_TRACE")]
	protected virtual void EnterRule(string ruleName, int ruleIndex) {}
	[Conditional("ANTLR_TRACE")]
	protected virtual void LeaveRule(string ruleName, int ruleIndex) {}

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__26() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__26() {}

    // $ANTLR start "T__26"
    [GrammarRule("T__26")]
    private void mT__26()
    {
    	EnterRule_T__26();
    	EnterRule("T__26", 1);
    	TraceIn("T__26", 1);
    		try
    		{
    		int _type = T__26;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:33:7: ( '!' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:33:9: '!'
    		{
    		DebugLocation(33, 9);
    		Match('!'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__26", 1);
    		LeaveRule("T__26", 1);
    		LeaveRule_T__26();
        }
    }
    // $ANTLR end "T__26"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__27() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__27() {}

    // $ANTLR start "T__27"
    [GrammarRule("T__27")]
    private void mT__27()
    {
    	EnterRule_T__27();
    	EnterRule("T__27", 2);
    	TraceIn("T__27", 2);
    		try
    		{
    		int _type = T__27;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:34:7: ( '!=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:34:9: '!='
    		{
    		DebugLocation(34, 9);
    		Match("!="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__27", 2);
    		LeaveRule("T__27", 2);
    		LeaveRule_T__27();
        }
    }
    // $ANTLR end "T__27"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__28() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__28() {}

    // $ANTLR start "T__28"
    [GrammarRule("T__28")]
    private void mT__28()
    {
    	EnterRule_T__28();
    	EnterRule("T__28", 3);
    	TraceIn("T__28", 3);
    		try
    		{
    		int _type = T__28;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:35:7: ( '%' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:35:9: '%'
    		{
    		DebugLocation(35, 9);
    		Match('%'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__28", 3);
    		LeaveRule("T__28", 3);
    		LeaveRule_T__28();
        }
    }
    // $ANTLR end "T__28"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__29() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__29() {}

    // $ANTLR start "T__29"
    [GrammarRule("T__29")]
    private void mT__29()
    {
    	EnterRule_T__29();
    	EnterRule("T__29", 4);
    	TraceIn("T__29", 4);
    		try
    		{
    		int _type = T__29;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:36:7: ( '%=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:36:9: '%='
    		{
    		DebugLocation(36, 9);
    		Match("%="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__29", 4);
    		LeaveRule("T__29", 4);
    		LeaveRule_T__29();
        }
    }
    // $ANTLR end "T__29"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__30() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__30() {}

    // $ANTLR start "T__30"
    [GrammarRule("T__30")]
    private void mT__30()
    {
    	EnterRule_T__30();
    	EnterRule("T__30", 5);
    	TraceIn("T__30", 5);
    		try
    		{
    		int _type = T__30;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:37:7: ( '&&' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:37:9: '&&'
    		{
    		DebugLocation(37, 9);
    		Match("&&"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__30", 5);
    		LeaveRule("T__30", 5);
    		LeaveRule_T__30();
        }
    }
    // $ANTLR end "T__30"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__31() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__31() {}

    // $ANTLR start "T__31"
    [GrammarRule("T__31")]
    private void mT__31()
    {
    	EnterRule_T__31();
    	EnterRule("T__31", 6);
    	TraceIn("T__31", 6);
    		try
    		{
    		int _type = T__31;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:38:7: ( '&' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:38:9: '&'
    		{
    		DebugLocation(38, 9);
    		Match('&'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__31", 6);
    		LeaveRule("T__31", 6);
    		LeaveRule_T__31();
        }
    }
    // $ANTLR end "T__31"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__32() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__32() {}

    // $ANTLR start "T__32"
    [GrammarRule("T__32")]
    private void mT__32()
    {
    	EnterRule_T__32();
    	EnterRule("T__32", 7);
    	TraceIn("T__32", 7);
    		try
    		{
    		int _type = T__32;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:39:7: ( '&=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:39:9: '&='
    		{
    		DebugLocation(39, 9);
    		Match("&="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__32", 7);
    		LeaveRule("T__32", 7);
    		LeaveRule_T__32();
        }
    }
    // $ANTLR end "T__32"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__33() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__33() {}

    // $ANTLR start "T__33"
    [GrammarRule("T__33")]
    private void mT__33()
    {
    	EnterRule_T__33();
    	EnterRule("T__33", 8);
    	TraceIn("T__33", 8);
    		try
    		{
    		int _type = T__33;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:40:7: ( '(' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:40:9: '('
    		{
    		DebugLocation(40, 9);
    		Match('('); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__33", 8);
    		LeaveRule("T__33", 8);
    		LeaveRule_T__33();
        }
    }
    // $ANTLR end "T__33"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__34() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__34() {}

    // $ANTLR start "T__34"
    [GrammarRule("T__34")]
    private void mT__34()
    {
    	EnterRule_T__34();
    	EnterRule("T__34", 9);
    	TraceIn("T__34", 9);
    		try
    		{
    		int _type = T__34;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:41:7: ( ')' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:41:9: ')'
    		{
    		DebugLocation(41, 9);
    		Match(')'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__34", 9);
    		LeaveRule("T__34", 9);
    		LeaveRule_T__34();
        }
    }
    // $ANTLR end "T__34"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__35() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__35() {}

    // $ANTLR start "T__35"
    [GrammarRule("T__35")]
    private void mT__35()
    {
    	EnterRule_T__35();
    	EnterRule("T__35", 10);
    	TraceIn("T__35", 10);
    		try
    		{
    		int _type = T__35;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:42:7: ( '*' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:42:9: '*'
    		{
    		DebugLocation(42, 9);
    		Match('*'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__35", 10);
    		LeaveRule("T__35", 10);
    		LeaveRule_T__35();
        }
    }
    // $ANTLR end "T__35"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__36() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__36() {}

    // $ANTLR start "T__36"
    [GrammarRule("T__36")]
    private void mT__36()
    {
    	EnterRule_T__36();
    	EnterRule("T__36", 11);
    	TraceIn("T__36", 11);
    		try
    		{
    		int _type = T__36;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:43:7: ( '*=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:43:9: '*='
    		{
    		DebugLocation(43, 9);
    		Match("*="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__36", 11);
    		LeaveRule("T__36", 11);
    		LeaveRule_T__36();
        }
    }
    // $ANTLR end "T__36"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__37() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__37() {}

    // $ANTLR start "T__37"
    [GrammarRule("T__37")]
    private void mT__37()
    {
    	EnterRule_T__37();
    	EnterRule("T__37", 12);
    	TraceIn("T__37", 12);
    		try
    		{
    		int _type = T__37;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:44:7: ( '+' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:44:9: '+'
    		{
    		DebugLocation(44, 9);
    		Match('+'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__37", 12);
    		LeaveRule("T__37", 12);
    		LeaveRule_T__37();
        }
    }
    // $ANTLR end "T__37"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__38() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__38() {}

    // $ANTLR start "T__38"
    [GrammarRule("T__38")]
    private void mT__38()
    {
    	EnterRule_T__38();
    	EnterRule("T__38", 13);
    	TraceIn("T__38", 13);
    		try
    		{
    		int _type = T__38;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:45:7: ( '++' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:45:9: '++'
    		{
    		DebugLocation(45, 9);
    		Match("++"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__38", 13);
    		LeaveRule("T__38", 13);
    		LeaveRule_T__38();
        }
    }
    // $ANTLR end "T__38"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__39() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__39() {}

    // $ANTLR start "T__39"
    [GrammarRule("T__39")]
    private void mT__39()
    {
    	EnterRule_T__39();
    	EnterRule("T__39", 14);
    	TraceIn("T__39", 14);
    		try
    		{
    		int _type = T__39;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:46:7: ( '+=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:46:9: '+='
    		{
    		DebugLocation(46, 9);
    		Match("+="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__39", 14);
    		LeaveRule("T__39", 14);
    		LeaveRule_T__39();
        }
    }
    // $ANTLR end "T__39"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__40() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__40() {}

    // $ANTLR start "T__40"
    [GrammarRule("T__40")]
    private void mT__40()
    {
    	EnterRule_T__40();
    	EnterRule("T__40", 15);
    	TraceIn("T__40", 15);
    		try
    		{
    		int _type = T__40;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:47:7: ( ',' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:47:9: ','
    		{
    		DebugLocation(47, 9);
    		Match(','); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__40", 15);
    		LeaveRule("T__40", 15);
    		LeaveRule_T__40();
        }
    }
    // $ANTLR end "T__40"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__41() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__41() {}

    // $ANTLR start "T__41"
    [GrammarRule("T__41")]
    private void mT__41()
    {
    	EnterRule_T__41();
    	EnterRule("T__41", 16);
    	TraceIn("T__41", 16);
    		try
    		{
    		int _type = T__41;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:48:7: ( '-' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:48:9: '-'
    		{
    		DebugLocation(48, 9);
    		Match('-'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__41", 16);
    		LeaveRule("T__41", 16);
    		LeaveRule_T__41();
        }
    }
    // $ANTLR end "T__41"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__42() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__42() {}

    // $ANTLR start "T__42"
    [GrammarRule("T__42")]
    private void mT__42()
    {
    	EnterRule_T__42();
    	EnterRule("T__42", 17);
    	TraceIn("T__42", 17);
    		try
    		{
    		int _type = T__42;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:49:7: ( '--' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:49:9: '--'
    		{
    		DebugLocation(49, 9);
    		Match("--"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__42", 17);
    		LeaveRule("T__42", 17);
    		LeaveRule_T__42();
        }
    }
    // $ANTLR end "T__42"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__43() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__43() {}

    // $ANTLR start "T__43"
    [GrammarRule("T__43")]
    private void mT__43()
    {
    	EnterRule_T__43();
    	EnterRule("T__43", 18);
    	TraceIn("T__43", 18);
    		try
    		{
    		int _type = T__43;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:50:7: ( '-=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:50:9: '-='
    		{
    		DebugLocation(50, 9);
    		Match("-="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__43", 18);
    		LeaveRule("T__43", 18);
    		LeaveRule_T__43();
        }
    }
    // $ANTLR end "T__43"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__44() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__44() {}

    // $ANTLR start "T__44"
    [GrammarRule("T__44")]
    private void mT__44()
    {
    	EnterRule_T__44();
    	EnterRule("T__44", 19);
    	TraceIn("T__44", 19);
    		try
    		{
    		int _type = T__44;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:51:7: ( '.' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:51:9: '.'
    		{
    		DebugLocation(51, 9);
    		Match('.'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__44", 19);
    		LeaveRule("T__44", 19);
    		LeaveRule_T__44();
        }
    }
    // $ANTLR end "T__44"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__45() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__45() {}

    // $ANTLR start "T__45"
    [GrammarRule("T__45")]
    private void mT__45()
    {
    	EnterRule_T__45();
    	EnterRule("T__45", 20);
    	TraceIn("T__45", 20);
    		try
    		{
    		int _type = T__45;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:52:7: ( '...' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:52:9: '...'
    		{
    		DebugLocation(52, 9);
    		Match("..."); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__45", 20);
    		LeaveRule("T__45", 20);
    		LeaveRule_T__45();
        }
    }
    // $ANTLR end "T__45"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__46() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__46() {}

    // $ANTLR start "T__46"
    [GrammarRule("T__46")]
    private void mT__46()
    {
    	EnterRule_T__46();
    	EnterRule("T__46", 21);
    	TraceIn("T__46", 21);
    		try
    		{
    		int _type = T__46;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:53:7: ( '/' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:53:9: '/'
    		{
    		DebugLocation(53, 9);
    		Match('/'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__46", 21);
    		LeaveRule("T__46", 21);
    		LeaveRule_T__46();
        }
    }
    // $ANTLR end "T__46"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__47() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__47() {}

    // $ANTLR start "T__47"
    [GrammarRule("T__47")]
    private void mT__47()
    {
    	EnterRule_T__47();
    	EnterRule("T__47", 22);
    	TraceIn("T__47", 22);
    		try
    		{
    		int _type = T__47;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:54:7: ( '/=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:54:9: '/='
    		{
    		DebugLocation(54, 9);
    		Match("/="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__47", 22);
    		LeaveRule("T__47", 22);
    		LeaveRule_T__47();
        }
    }
    // $ANTLR end "T__47"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__48() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__48() {}

    // $ANTLR start "T__48"
    [GrammarRule("T__48")]
    private void mT__48()
    {
    	EnterRule_T__48();
    	EnterRule("T__48", 23);
    	TraceIn("T__48", 23);
    		try
    		{
    		int _type = T__48;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:55:7: ( ':' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:55:9: ':'
    		{
    		DebugLocation(55, 9);
    		Match(':'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__48", 23);
    		LeaveRule("T__48", 23);
    		LeaveRule_T__48();
        }
    }
    // $ANTLR end "T__48"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__49() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__49() {}

    // $ANTLR start "T__49"
    [GrammarRule("T__49")]
    private void mT__49()
    {
    	EnterRule_T__49();
    	EnterRule("T__49", 24);
    	TraceIn("T__49", 24);
    		try
    		{
    		int _type = T__49;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:56:7: ( ';' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:56:9: ';'
    		{
    		DebugLocation(56, 9);
    		Match(';'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__49", 24);
    		LeaveRule("T__49", 24);
    		LeaveRule_T__49();
        }
    }
    // $ANTLR end "T__49"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__50() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__50() {}

    // $ANTLR start "T__50"
    [GrammarRule("T__50")]
    private void mT__50()
    {
    	EnterRule_T__50();
    	EnterRule("T__50", 25);
    	TraceIn("T__50", 25);
    		try
    		{
    		int _type = T__50;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:57:7: ( '<' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:57:9: '<'
    		{
    		DebugLocation(57, 9);
    		Match('<'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__50", 25);
    		LeaveRule("T__50", 25);
    		LeaveRule_T__50();
        }
    }
    // $ANTLR end "T__50"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__51() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__51() {}

    // $ANTLR start "T__51"
    [GrammarRule("T__51")]
    private void mT__51()
    {
    	EnterRule_T__51();
    	EnterRule("T__51", 26);
    	TraceIn("T__51", 26);
    		try
    		{
    		int _type = T__51;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:58:7: ( '=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:58:9: '='
    		{
    		DebugLocation(58, 9);
    		Match('='); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__51", 26);
    		LeaveRule("T__51", 26);
    		LeaveRule_T__51();
        }
    }
    // $ANTLR end "T__51"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__52() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__52() {}

    // $ANTLR start "T__52"
    [GrammarRule("T__52")]
    private void mT__52()
    {
    	EnterRule_T__52();
    	EnterRule("T__52", 27);
    	TraceIn("T__52", 27);
    		try
    		{
    		int _type = T__52;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:59:7: ( '==' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:59:9: '=='
    		{
    		DebugLocation(59, 9);
    		Match("=="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__52", 27);
    		LeaveRule("T__52", 27);
    		LeaveRule_T__52();
        }
    }
    // $ANTLR end "T__52"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__53() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__53() {}

    // $ANTLR start "T__53"
    [GrammarRule("T__53")]
    private void mT__53()
    {
    	EnterRule_T__53();
    	EnterRule("T__53", 28);
    	TraceIn("T__53", 28);
    		try
    		{
    		int _type = T__53;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:60:7: ( '>' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:60:9: '>'
    		{
    		DebugLocation(60, 9);
    		Match('>'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__53", 28);
    		LeaveRule("T__53", 28);
    		LeaveRule_T__53();
        }
    }
    // $ANTLR end "T__53"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__54() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__54() {}

    // $ANTLR start "T__54"
    [GrammarRule("T__54")]
    private void mT__54()
    {
    	EnterRule_T__54();
    	EnterRule("T__54", 29);
    	TraceIn("T__54", 29);
    		try
    		{
    		int _type = T__54;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:61:7: ( '?' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:61:9: '?'
    		{
    		DebugLocation(61, 9);
    		Match('?'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__54", 29);
    		LeaveRule("T__54", 29);
    		LeaveRule_T__54();
        }
    }
    // $ANTLR end "T__54"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__55() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__55() {}

    // $ANTLR start "T__55"
    [GrammarRule("T__55")]
    private void mT__55()
    {
    	EnterRule_T__55();
    	EnterRule("T__55", 30);
    	TraceIn("T__55", 30);
    		try
    		{
    		int _type = T__55;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:62:7: ( '@' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:62:9: '@'
    		{
    		DebugLocation(62, 9);
    		Match('@'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__55", 30);
    		LeaveRule("T__55", 30);
    		LeaveRule_T__55();
        }
    }
    // $ANTLR end "T__55"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__56() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__56() {}

    // $ANTLR start "T__56"
    [GrammarRule("T__56")]
    private void mT__56()
    {
    	EnterRule_T__56();
    	EnterRule("T__56", 31);
    	TraceIn("T__56", 31);
    		try
    		{
    		int _type = T__56;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:63:7: ( '[' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:63:9: '['
    		{
    		DebugLocation(63, 9);
    		Match('['); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__56", 31);
    		LeaveRule("T__56", 31);
    		LeaveRule_T__56();
        }
    }
    // $ANTLR end "T__56"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__57() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__57() {}

    // $ANTLR start "T__57"
    [GrammarRule("T__57")]
    private void mT__57()
    {
    	EnterRule_T__57();
    	EnterRule("T__57", 32);
    	TraceIn("T__57", 32);
    		try
    		{
    		int _type = T__57;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:64:7: ( ']' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:64:9: ']'
    		{
    		DebugLocation(64, 9);
    		Match(']'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__57", 32);
    		LeaveRule("T__57", 32);
    		LeaveRule_T__57();
        }
    }
    // $ANTLR end "T__57"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__58() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__58() {}

    // $ANTLR start "T__58"
    [GrammarRule("T__58")]
    private void mT__58()
    {
    	EnterRule_T__58();
    	EnterRule("T__58", 33);
    	TraceIn("T__58", 33);
    		try
    		{
    		int _type = T__58;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:65:7: ( '^' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:65:9: '^'
    		{
    		DebugLocation(65, 9);
    		Match('^'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__58", 33);
    		LeaveRule("T__58", 33);
    		LeaveRule_T__58();
        }
    }
    // $ANTLR end "T__58"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__59() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__59() {}

    // $ANTLR start "T__59"
    [GrammarRule("T__59")]
    private void mT__59()
    {
    	EnterRule_T__59();
    	EnterRule("T__59", 34);
    	TraceIn("T__59", 34);
    		try
    		{
    		int _type = T__59;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:66:7: ( '^=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:66:9: '^='
    		{
    		DebugLocation(66, 9);
    		Match("^="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__59", 34);
    		LeaveRule("T__59", 34);
    		LeaveRule_T__59();
        }
    }
    // $ANTLR end "T__59"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__60() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__60() {}

    // $ANTLR start "T__60"
    [GrammarRule("T__60")]
    private void mT__60()
    {
    	EnterRule_T__60();
    	EnterRule("T__60", 35);
    	TraceIn("T__60", 35);
    		try
    		{
    		int _type = T__60;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:67:7: ( 'abstract' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:67:9: 'abstract'
    		{
    		DebugLocation(67, 9);
    		Match("abstract"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__60", 35);
    		LeaveRule("T__60", 35);
    		LeaveRule_T__60();
        }
    }
    // $ANTLR end "T__60"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__61() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__61() {}

    // $ANTLR start "T__61"
    [GrammarRule("T__61")]
    private void mT__61()
    {
    	EnterRule_T__61();
    	EnterRule("T__61", 36);
    	TraceIn("T__61", 36);
    		try
    		{
    		int _type = T__61;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:68:7: ( 'boolean' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:68:9: 'boolean'
    		{
    		DebugLocation(68, 9);
    		Match("boolean"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__61", 36);
    		LeaveRule("T__61", 36);
    		LeaveRule_T__61();
        }
    }
    // $ANTLR end "T__61"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__62() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__62() {}

    // $ANTLR start "T__62"
    [GrammarRule("T__62")]
    private void mT__62()
    {
    	EnterRule_T__62();
    	EnterRule("T__62", 37);
    	TraceIn("T__62", 37);
    		try
    		{
    		int _type = T__62;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:69:7: ( 'break' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:69:9: 'break'
    		{
    		DebugLocation(69, 9);
    		Match("break"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__62", 37);
    		LeaveRule("T__62", 37);
    		LeaveRule_T__62();
        }
    }
    // $ANTLR end "T__62"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__63() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__63() {}

    // $ANTLR start "T__63"
    [GrammarRule("T__63")]
    private void mT__63()
    {
    	EnterRule_T__63();
    	EnterRule("T__63", 38);
    	TraceIn("T__63", 38);
    		try
    		{
    		int _type = T__63;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:70:7: ( 'byte' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:70:9: 'byte'
    		{
    		DebugLocation(70, 9);
    		Match("byte"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__63", 38);
    		LeaveRule("T__63", 38);
    		LeaveRule_T__63();
        }
    }
    // $ANTLR end "T__63"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__64() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__64() {}

    // $ANTLR start "T__64"
    [GrammarRule("T__64")]
    private void mT__64()
    {
    	EnterRule_T__64();
    	EnterRule("T__64", 39);
    	TraceIn("T__64", 39);
    		try
    		{
    		int _type = T__64;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:71:7: ( 'case' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:71:9: 'case'
    		{
    		DebugLocation(71, 9);
    		Match("case"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__64", 39);
    		LeaveRule("T__64", 39);
    		LeaveRule_T__64();
        }
    }
    // $ANTLR end "T__64"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__65() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__65() {}

    // $ANTLR start "T__65"
    [GrammarRule("T__65")]
    private void mT__65()
    {
    	EnterRule_T__65();
    	EnterRule("T__65", 40);
    	TraceIn("T__65", 40);
    		try
    		{
    		int _type = T__65;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:72:7: ( 'catch' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:72:9: 'catch'
    		{
    		DebugLocation(72, 9);
    		Match("catch"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__65", 40);
    		LeaveRule("T__65", 40);
    		LeaveRule_T__65();
        }
    }
    // $ANTLR end "T__65"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__66() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__66() {}

    // $ANTLR start "T__66"
    [GrammarRule("T__66")]
    private void mT__66()
    {
    	EnterRule_T__66();
    	EnterRule("T__66", 41);
    	TraceIn("T__66", 41);
    		try
    		{
    		int _type = T__66;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:73:7: ( 'char' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:73:9: 'char'
    		{
    		DebugLocation(73, 9);
    		Match("char"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__66", 41);
    		LeaveRule("T__66", 41);
    		LeaveRule_T__66();
        }
    }
    // $ANTLR end "T__66"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__67() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__67() {}

    // $ANTLR start "T__67"
    [GrammarRule("T__67")]
    private void mT__67()
    {
    	EnterRule_T__67();
    	EnterRule("T__67", 42);
    	TraceIn("T__67", 42);
    		try
    		{
    		int _type = T__67;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:74:7: ( 'class' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:74:9: 'class'
    		{
    		DebugLocation(74, 9);
    		Match("class"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__67", 42);
    		LeaveRule("T__67", 42);
    		LeaveRule_T__67();
        }
    }
    // $ANTLR end "T__67"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__68() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__68() {}

    // $ANTLR start "T__68"
    [GrammarRule("T__68")]
    private void mT__68()
    {
    	EnterRule_T__68();
    	EnterRule("T__68", 43);
    	TraceIn("T__68", 43);
    		try
    		{
    		int _type = T__68;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:75:7: ( 'continue' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:75:9: 'continue'
    		{
    		DebugLocation(75, 9);
    		Match("continue"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__68", 43);
    		LeaveRule("T__68", 43);
    		LeaveRule_T__68();
        }
    }
    // $ANTLR end "T__68"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__69() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__69() {}

    // $ANTLR start "T__69"
    [GrammarRule("T__69")]
    private void mT__69()
    {
    	EnterRule_T__69();
    	EnterRule("T__69", 44);
    	TraceIn("T__69", 44);
    		try
    		{
    		int _type = T__69;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:76:7: ( 'default' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:76:9: 'default'
    		{
    		DebugLocation(76, 9);
    		Match("default"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__69", 44);
    		LeaveRule("T__69", 44);
    		LeaveRule_T__69();
        }
    }
    // $ANTLR end "T__69"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__70() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__70() {}

    // $ANTLR start "T__70"
    [GrammarRule("T__70")]
    private void mT__70()
    {
    	EnterRule_T__70();
    	EnterRule("T__70", 45);
    	TraceIn("T__70", 45);
    		try
    		{
    		int _type = T__70;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:77:7: ( 'do' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:77:9: 'do'
    		{
    		DebugLocation(77, 9);
    		Match("do"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__70", 45);
    		LeaveRule("T__70", 45);
    		LeaveRule_T__70();
        }
    }
    // $ANTLR end "T__70"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__71() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__71() {}

    // $ANTLR start "T__71"
    [GrammarRule("T__71")]
    private void mT__71()
    {
    	EnterRule_T__71();
    	EnterRule("T__71", 46);
    	TraceIn("T__71", 46);
    		try
    		{
    		int _type = T__71;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:78:7: ( 'double' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:78:9: 'double'
    		{
    		DebugLocation(78, 9);
    		Match("double"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__71", 46);
    		LeaveRule("T__71", 46);
    		LeaveRule_T__71();
        }
    }
    // $ANTLR end "T__71"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__72() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__72() {}

    // $ANTLR start "T__72"
    [GrammarRule("T__72")]
    private void mT__72()
    {
    	EnterRule_T__72();
    	EnterRule("T__72", 47);
    	TraceIn("T__72", 47);
    		try
    		{
    		int _type = T__72;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:79:7: ( 'else' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:79:9: 'else'
    		{
    		DebugLocation(79, 9);
    		Match("else"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__72", 47);
    		LeaveRule("T__72", 47);
    		LeaveRule_T__72();
        }
    }
    // $ANTLR end "T__72"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__73() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__73() {}

    // $ANTLR start "T__73"
    [GrammarRule("T__73")]
    private void mT__73()
    {
    	EnterRule_T__73();
    	EnterRule("T__73", 48);
    	TraceIn("T__73", 48);
    		try
    		{
    		int _type = T__73;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:80:7: ( 'extends' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:80:9: 'extends'
    		{
    		DebugLocation(80, 9);
    		Match("extends"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__73", 48);
    		LeaveRule("T__73", 48);
    		LeaveRule_T__73();
        }
    }
    // $ANTLR end "T__73"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__74() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__74() {}

    // $ANTLR start "T__74"
    [GrammarRule("T__74")]
    private void mT__74()
    {
    	EnterRule_T__74();
    	EnterRule("T__74", 49);
    	TraceIn("T__74", 49);
    		try
    		{
    		int _type = T__74;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:81:7: ( 'false' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:81:9: 'false'
    		{
    		DebugLocation(81, 9);
    		Match("false"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__74", 49);
    		LeaveRule("T__74", 49);
    		LeaveRule_T__74();
        }
    }
    // $ANTLR end "T__74"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__75() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__75() {}

    // $ANTLR start "T__75"
    [GrammarRule("T__75")]
    private void mT__75()
    {
    	EnterRule_T__75();
    	EnterRule("T__75", 50);
    	TraceIn("T__75", 50);
    		try
    		{
    		int _type = T__75;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:82:7: ( 'final' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:82:9: 'final'
    		{
    		DebugLocation(82, 9);
    		Match("final"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__75", 50);
    		LeaveRule("T__75", 50);
    		LeaveRule_T__75();
        }
    }
    // $ANTLR end "T__75"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__76() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__76() {}

    // $ANTLR start "T__76"
    [GrammarRule("T__76")]
    private void mT__76()
    {
    	EnterRule_T__76();
    	EnterRule("T__76", 51);
    	TraceIn("T__76", 51);
    		try
    		{
    		int _type = T__76;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:83:7: ( 'finally' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:83:9: 'finally'
    		{
    		DebugLocation(83, 9);
    		Match("finally"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__76", 51);
    		LeaveRule("T__76", 51);
    		LeaveRule_T__76();
        }
    }
    // $ANTLR end "T__76"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__77() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__77() {}

    // $ANTLR start "T__77"
    [GrammarRule("T__77")]
    private void mT__77()
    {
    	EnterRule_T__77();
    	EnterRule("T__77", 52);
    	TraceIn("T__77", 52);
    		try
    		{
    		int _type = T__77;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:84:7: ( 'float' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:84:9: 'float'
    		{
    		DebugLocation(84, 9);
    		Match("float"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__77", 52);
    		LeaveRule("T__77", 52);
    		LeaveRule_T__77();
        }
    }
    // $ANTLR end "T__77"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__78() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__78() {}

    // $ANTLR start "T__78"
    [GrammarRule("T__78")]
    private void mT__78()
    {
    	EnterRule_T__78();
    	EnterRule("T__78", 53);
    	TraceIn("T__78", 53);
    		try
    		{
    		int _type = T__78;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:85:7: ( 'for' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:85:9: 'for'
    		{
    		DebugLocation(85, 9);
    		Match("for"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__78", 53);
    		LeaveRule("T__78", 53);
    		LeaveRule_T__78();
        }
    }
    // $ANTLR end "T__78"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__79() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__79() {}

    // $ANTLR start "T__79"
    [GrammarRule("T__79")]
    private void mT__79()
    {
    	EnterRule_T__79();
    	EnterRule("T__79", 54);
    	TraceIn("T__79", 54);
    		try
    		{
    		int _type = T__79;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:86:7: ( 'if' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:86:9: 'if'
    		{
    		DebugLocation(86, 9);
    		Match("if"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__79", 54);
    		LeaveRule("T__79", 54);
    		LeaveRule_T__79();
        }
    }
    // $ANTLR end "T__79"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__80() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__80() {}

    // $ANTLR start "T__80"
    [GrammarRule("T__80")]
    private void mT__80()
    {
    	EnterRule_T__80();
    	EnterRule("T__80", 55);
    	TraceIn("T__80", 55);
    		try
    		{
    		int _type = T__80;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:87:7: ( 'implements' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:87:9: 'implements'
    		{
    		DebugLocation(87, 9);
    		Match("implements"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__80", 55);
    		LeaveRule("T__80", 55);
    		LeaveRule_T__80();
        }
    }
    // $ANTLR end "T__80"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__81() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__81() {}

    // $ANTLR start "T__81"
    [GrammarRule("T__81")]
    private void mT__81()
    {
    	EnterRule_T__81();
    	EnterRule("T__81", 56);
    	TraceIn("T__81", 56);
    		try
    		{
    		int _type = T__81;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:88:7: ( 'import' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:88:9: 'import'
    		{
    		DebugLocation(88, 9);
    		Match("import"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__81", 56);
    		LeaveRule("T__81", 56);
    		LeaveRule_T__81();
        }
    }
    // $ANTLR end "T__81"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__82() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__82() {}

    // $ANTLR start "T__82"
    [GrammarRule("T__82")]
    private void mT__82()
    {
    	EnterRule_T__82();
    	EnterRule("T__82", 57);
    	TraceIn("T__82", 57);
    		try
    		{
    		int _type = T__82;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:89:7: ( 'instanceof' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:89:9: 'instanceof'
    		{
    		DebugLocation(89, 9);
    		Match("instanceof"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__82", 57);
    		LeaveRule("T__82", 57);
    		LeaveRule_T__82();
        }
    }
    // $ANTLR end "T__82"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__83() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__83() {}

    // $ANTLR start "T__83"
    [GrammarRule("T__83")]
    private void mT__83()
    {
    	EnterRule_T__83();
    	EnterRule("T__83", 58);
    	TraceIn("T__83", 58);
    		try
    		{
    		int _type = T__83;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:90:7: ( 'int' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:90:9: 'int'
    		{
    		DebugLocation(90, 9);
    		Match("int"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__83", 58);
    		LeaveRule("T__83", 58);
    		LeaveRule_T__83();
        }
    }
    // $ANTLR end "T__83"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__84() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__84() {}

    // $ANTLR start "T__84"
    [GrammarRule("T__84")]
    private void mT__84()
    {
    	EnterRule_T__84();
    	EnterRule("T__84", 59);
    	TraceIn("T__84", 59);
    		try
    		{
    		int _type = T__84;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:91:7: ( 'interface' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:91:9: 'interface'
    		{
    		DebugLocation(91, 9);
    		Match("interface"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__84", 59);
    		LeaveRule("T__84", 59);
    		LeaveRule_T__84();
        }
    }
    // $ANTLR end "T__84"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__85() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__85() {}

    // $ANTLR start "T__85"
    [GrammarRule("T__85")]
    private void mT__85()
    {
    	EnterRule_T__85();
    	EnterRule("T__85", 60);
    	TraceIn("T__85", 60);
    		try
    		{
    		int _type = T__85;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:92:7: ( 'long' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:92:9: 'long'
    		{
    		DebugLocation(92, 9);
    		Match("long"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__85", 60);
    		LeaveRule("T__85", 60);
    		LeaveRule_T__85();
        }
    }
    // $ANTLR end "T__85"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__86() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__86() {}

    // $ANTLR start "T__86"
    [GrammarRule("T__86")]
    private void mT__86()
    {
    	EnterRule_T__86();
    	EnterRule("T__86", 61);
    	TraceIn("T__86", 61);
    		try
    		{
    		int _type = T__86;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:93:7: ( 'native' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:93:9: 'native'
    		{
    		DebugLocation(93, 9);
    		Match("native"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__86", 61);
    		LeaveRule("T__86", 61);
    		LeaveRule_T__86();
        }
    }
    // $ANTLR end "T__86"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__87() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__87() {}

    // $ANTLR start "T__87"
    [GrammarRule("T__87")]
    private void mT__87()
    {
    	EnterRule_T__87();
    	EnterRule("T__87", 62);
    	TraceIn("T__87", 62);
    		try
    		{
    		int _type = T__87;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:94:7: ( 'new' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:94:9: 'new'
    		{
    		DebugLocation(94, 9);
    		Match("new"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__87", 62);
    		LeaveRule("T__87", 62);
    		LeaveRule_T__87();
        }
    }
    // $ANTLR end "T__87"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__88() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__88() {}

    // $ANTLR start "T__88"
    [GrammarRule("T__88")]
    private void mT__88()
    {
    	EnterRule_T__88();
    	EnterRule("T__88", 63);
    	TraceIn("T__88", 63);
    		try
    		{
    		int _type = T__88;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:95:7: ( 'null' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:95:9: 'null'
    		{
    		DebugLocation(95, 9);
    		Match("null"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__88", 63);
    		LeaveRule("T__88", 63);
    		LeaveRule_T__88();
        }
    }
    // $ANTLR end "T__88"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__89() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__89() {}

    // $ANTLR start "T__89"
    [GrammarRule("T__89")]
    private void mT__89()
    {
    	EnterRule_T__89();
    	EnterRule("T__89", 64);
    	TraceIn("T__89", 64);
    		try
    		{
    		int _type = T__89;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:96:7: ( 'package' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:96:9: 'package'
    		{
    		DebugLocation(96, 9);
    		Match("package"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__89", 64);
    		LeaveRule("T__89", 64);
    		LeaveRule_T__89();
        }
    }
    // $ANTLR end "T__89"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__90() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__90() {}

    // $ANTLR start "T__90"
    [GrammarRule("T__90")]
    private void mT__90()
    {
    	EnterRule_T__90();
    	EnterRule("T__90", 65);
    	TraceIn("T__90", 65);
    		try
    		{
    		int _type = T__90;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:97:7: ( 'private' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:97:9: 'private'
    		{
    		DebugLocation(97, 9);
    		Match("private"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__90", 65);
    		LeaveRule("T__90", 65);
    		LeaveRule_T__90();
        }
    }
    // $ANTLR end "T__90"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__91() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__91() {}

    // $ANTLR start "T__91"
    [GrammarRule("T__91")]
    private void mT__91()
    {
    	EnterRule_T__91();
    	EnterRule("T__91", 66);
    	TraceIn("T__91", 66);
    		try
    		{
    		int _type = T__91;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:98:7: ( 'protected' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:98:9: 'protected'
    		{
    		DebugLocation(98, 9);
    		Match("protected"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__91", 66);
    		LeaveRule("T__91", 66);
    		LeaveRule_T__91();
        }
    }
    // $ANTLR end "T__91"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__92() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__92() {}

    // $ANTLR start "T__92"
    [GrammarRule("T__92")]
    private void mT__92()
    {
    	EnterRule_T__92();
    	EnterRule("T__92", 67);
    	TraceIn("T__92", 67);
    		try
    		{
    		int _type = T__92;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:99:7: ( 'public' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:99:9: 'public'
    		{
    		DebugLocation(99, 9);
    		Match("public"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__92", 67);
    		LeaveRule("T__92", 67);
    		LeaveRule_T__92();
        }
    }
    // $ANTLR end "T__92"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__93() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__93() {}

    // $ANTLR start "T__93"
    [GrammarRule("T__93")]
    private void mT__93()
    {
    	EnterRule_T__93();
    	EnterRule("T__93", 68);
    	TraceIn("T__93", 68);
    		try
    		{
    		int _type = T__93;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:100:7: ( 'return' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:100:9: 'return'
    		{
    		DebugLocation(100, 9);
    		Match("return"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__93", 68);
    		LeaveRule("T__93", 68);
    		LeaveRule_T__93();
        }
    }
    // $ANTLR end "T__93"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__94() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__94() {}

    // $ANTLR start "T__94"
    [GrammarRule("T__94")]
    private void mT__94()
    {
    	EnterRule_T__94();
    	EnterRule("T__94", 69);
    	TraceIn("T__94", 69);
    		try
    		{
    		int _type = T__94;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:101:7: ( 'short' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:101:9: 'short'
    		{
    		DebugLocation(101, 9);
    		Match("short"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__94", 69);
    		LeaveRule("T__94", 69);
    		LeaveRule_T__94();
        }
    }
    // $ANTLR end "T__94"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__95() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__95() {}

    // $ANTLR start "T__95"
    [GrammarRule("T__95")]
    private void mT__95()
    {
    	EnterRule_T__95();
    	EnterRule("T__95", 70);
    	TraceIn("T__95", 70);
    		try
    		{
    		int _type = T__95;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:102:7: ( 'static' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:102:9: 'static'
    		{
    		DebugLocation(102, 9);
    		Match("static"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__95", 70);
    		LeaveRule("T__95", 70);
    		LeaveRule_T__95();
        }
    }
    // $ANTLR end "T__95"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__96() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__96() {}

    // $ANTLR start "T__96"
    [GrammarRule("T__96")]
    private void mT__96()
    {
    	EnterRule_T__96();
    	EnterRule("T__96", 71);
    	TraceIn("T__96", 71);
    		try
    		{
    		int _type = T__96;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:103:7: ( 'strictfp' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:103:9: 'strictfp'
    		{
    		DebugLocation(103, 9);
    		Match("strictfp"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__96", 71);
    		LeaveRule("T__96", 71);
    		LeaveRule_T__96();
        }
    }
    // $ANTLR end "T__96"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__97() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__97() {}

    // $ANTLR start "T__97"
    [GrammarRule("T__97")]
    private void mT__97()
    {
    	EnterRule_T__97();
    	EnterRule("T__97", 72);
    	TraceIn("T__97", 72);
    		try
    		{
    		int _type = T__97;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:104:7: ( 'super' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:104:9: 'super'
    		{
    		DebugLocation(104, 9);
    		Match("super"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__97", 72);
    		LeaveRule("T__97", 72);
    		LeaveRule_T__97();
        }
    }
    // $ANTLR end "T__97"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__98() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__98() {}

    // $ANTLR start "T__98"
    [GrammarRule("T__98")]
    private void mT__98()
    {
    	EnterRule_T__98();
    	EnterRule("T__98", 73);
    	TraceIn("T__98", 73);
    		try
    		{
    		int _type = T__98;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:105:7: ( 'switch' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:105:9: 'switch'
    		{
    		DebugLocation(105, 9);
    		Match("switch"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__98", 73);
    		LeaveRule("T__98", 73);
    		LeaveRule_T__98();
        }
    }
    // $ANTLR end "T__98"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__99() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__99() {}

    // $ANTLR start "T__99"
    [GrammarRule("T__99")]
    private void mT__99()
    {
    	EnterRule_T__99();
    	EnterRule("T__99", 74);
    	TraceIn("T__99", 74);
    		try
    		{
    		int _type = T__99;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:106:7: ( 'synchronized' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:106:9: 'synchronized'
    		{
    		DebugLocation(106, 9);
    		Match("synchronized"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__99", 74);
    		LeaveRule("T__99", 74);
    		LeaveRule_T__99();
        }
    }
    // $ANTLR end "T__99"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__100() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__100() {}

    // $ANTLR start "T__100"
    [GrammarRule("T__100")]
    private void mT__100()
    {
    	EnterRule_T__100();
    	EnterRule("T__100", 75);
    	TraceIn("T__100", 75);
    		try
    		{
    		int _type = T__100;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:107:8: ( 'this' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:107:10: 'this'
    		{
    		DebugLocation(107, 10);
    		Match("this"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__100", 75);
    		LeaveRule("T__100", 75);
    		LeaveRule_T__100();
        }
    }
    // $ANTLR end "T__100"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__101() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__101() {}

    // $ANTLR start "T__101"
    [GrammarRule("T__101")]
    private void mT__101()
    {
    	EnterRule_T__101();
    	EnterRule("T__101", 76);
    	TraceIn("T__101", 76);
    		try
    		{
    		int _type = T__101;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:108:8: ( 'throw' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:108:10: 'throw'
    		{
    		DebugLocation(108, 10);
    		Match("throw"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__101", 76);
    		LeaveRule("T__101", 76);
    		LeaveRule_T__101();
        }
    }
    // $ANTLR end "T__101"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__102() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__102() {}

    // $ANTLR start "T__102"
    [GrammarRule("T__102")]
    private void mT__102()
    {
    	EnterRule_T__102();
    	EnterRule("T__102", 77);
    	TraceIn("T__102", 77);
    		try
    		{
    		int _type = T__102;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:109:8: ( 'throws' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:109:10: 'throws'
    		{
    		DebugLocation(109, 10);
    		Match("throws"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__102", 77);
    		LeaveRule("T__102", 77);
    		LeaveRule_T__102();
        }
    }
    // $ANTLR end "T__102"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__103() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__103() {}

    // $ANTLR start "T__103"
    [GrammarRule("T__103")]
    private void mT__103()
    {
    	EnterRule_T__103();
    	EnterRule("T__103", 78);
    	TraceIn("T__103", 78);
    		try
    		{
    		int _type = T__103;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:110:8: ( 'transient' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:110:10: 'transient'
    		{
    		DebugLocation(110, 10);
    		Match("transient"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__103", 78);
    		LeaveRule("T__103", 78);
    		LeaveRule_T__103();
        }
    }
    // $ANTLR end "T__103"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__104() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__104() {}

    // $ANTLR start "T__104"
    [GrammarRule("T__104")]
    private void mT__104()
    {
    	EnterRule_T__104();
    	EnterRule("T__104", 79);
    	TraceIn("T__104", 79);
    		try
    		{
    		int _type = T__104;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:111:8: ( 'true' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:111:10: 'true'
    		{
    		DebugLocation(111, 10);
    		Match("true"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__104", 79);
    		LeaveRule("T__104", 79);
    		LeaveRule_T__104();
        }
    }
    // $ANTLR end "T__104"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__105() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__105() {}

    // $ANTLR start "T__105"
    [GrammarRule("T__105")]
    private void mT__105()
    {
    	EnterRule_T__105();
    	EnterRule("T__105", 80);
    	TraceIn("T__105", 80);
    		try
    		{
    		int _type = T__105;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:112:8: ( 'try' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:112:10: 'try'
    		{
    		DebugLocation(112, 10);
    		Match("try"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__105", 80);
    		LeaveRule("T__105", 80);
    		LeaveRule_T__105();
        }
    }
    // $ANTLR end "T__105"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__106() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__106() {}

    // $ANTLR start "T__106"
    [GrammarRule("T__106")]
    private void mT__106()
    {
    	EnterRule_T__106();
    	EnterRule("T__106", 81);
    	TraceIn("T__106", 81);
    		try
    		{
    		int _type = T__106;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:113:8: ( 'void' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:113:10: 'void'
    		{
    		DebugLocation(113, 10);
    		Match("void"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__106", 81);
    		LeaveRule("T__106", 81);
    		LeaveRule_T__106();
        }
    }
    // $ANTLR end "T__106"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__107() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__107() {}

    // $ANTLR start "T__107"
    [GrammarRule("T__107")]
    private void mT__107()
    {
    	EnterRule_T__107();
    	EnterRule("T__107", 82);
    	TraceIn("T__107", 82);
    		try
    		{
    		int _type = T__107;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:114:8: ( 'volatile' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:114:10: 'volatile'
    		{
    		DebugLocation(114, 10);
    		Match("volatile"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__107", 82);
    		LeaveRule("T__107", 82);
    		LeaveRule_T__107();
        }
    }
    // $ANTLR end "T__107"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__108() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__108() {}

    // $ANTLR start "T__108"
    [GrammarRule("T__108")]
    private void mT__108()
    {
    	EnterRule_T__108();
    	EnterRule("T__108", 83);
    	TraceIn("T__108", 83);
    		try
    		{
    		int _type = T__108;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:115:8: ( 'while' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:115:10: 'while'
    		{
    		DebugLocation(115, 10);
    		Match("while"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__108", 83);
    		LeaveRule("T__108", 83);
    		LeaveRule_T__108();
        }
    }
    // $ANTLR end "T__108"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__109() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__109() {}

    // $ANTLR start "T__109"
    [GrammarRule("T__109")]
    private void mT__109()
    {
    	EnterRule_T__109();
    	EnterRule("T__109", 84);
    	TraceIn("T__109", 84);
    		try
    		{
    		int _type = T__109;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:116:8: ( '{' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:116:10: '{'
    		{
    		DebugLocation(116, 10);
    		Match('{'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__109", 84);
    		LeaveRule("T__109", 84);
    		LeaveRule_T__109();
        }
    }
    // $ANTLR end "T__109"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__110() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__110() {}

    // $ANTLR start "T__110"
    [GrammarRule("T__110")]
    private void mT__110()
    {
    	EnterRule_T__110();
    	EnterRule("T__110", 85);
    	TraceIn("T__110", 85);
    		try
    		{
    		int _type = T__110;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:117:8: ( '|' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:117:10: '|'
    		{
    		DebugLocation(117, 10);
    		Match('|'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__110", 85);
    		LeaveRule("T__110", 85);
    		LeaveRule_T__110();
        }
    }
    // $ANTLR end "T__110"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__111() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__111() {}

    // $ANTLR start "T__111"
    [GrammarRule("T__111")]
    private void mT__111()
    {
    	EnterRule_T__111();
    	EnterRule("T__111", 86);
    	TraceIn("T__111", 86);
    		try
    		{
    		int _type = T__111;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:118:8: ( '|=' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:118:10: '|='
    		{
    		DebugLocation(118, 10);
    		Match("|="); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__111", 86);
    		LeaveRule("T__111", 86);
    		LeaveRule_T__111();
        }
    }
    // $ANTLR end "T__111"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__112() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__112() {}

    // $ANTLR start "T__112"
    [GrammarRule("T__112")]
    private void mT__112()
    {
    	EnterRule_T__112();
    	EnterRule("T__112", 87);
    	TraceIn("T__112", 87);
    		try
    		{
    		int _type = T__112;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:119:8: ( '||' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:119:10: '||'
    		{
    		DebugLocation(119, 10);
    		Match("||"); 


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__112", 87);
    		LeaveRule("T__112", 87);
    		LeaveRule_T__112();
        }
    }
    // $ANTLR end "T__112"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__113() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__113() {}

    // $ANTLR start "T__113"
    [GrammarRule("T__113")]
    private void mT__113()
    {
    	EnterRule_T__113();
    	EnterRule("T__113", 88);
    	TraceIn("T__113", 88);
    		try
    		{
    		int _type = T__113;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:120:8: ( '}' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:120:10: '}'
    		{
    		DebugLocation(120, 10);
    		Match('}'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__113", 88);
    		LeaveRule("T__113", 88);
    		LeaveRule_T__113();
        }
    }
    // $ANTLR end "T__113"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_T__114() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_T__114() {}

    // $ANTLR start "T__114"
    [GrammarRule("T__114")]
    private void mT__114()
    {
    	EnterRule_T__114();
    	EnterRule("T__114", 89);
    	TraceIn("T__114", 89);
    		try
    		{
    		int _type = T__114;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:121:8: ( '~' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:121:10: '~'
    		{
    		DebugLocation(121, 10);
    		Match('~'); 

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("T__114", 89);
    		LeaveRule("T__114", 89);
    		LeaveRule_T__114();
        }
    }
    // $ANTLR end "T__114"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_HexLiteral() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_HexLiteral() {}

    // $ANTLR start "HexLiteral"
    [GrammarRule("HexLiteral")]
    private void mHexLiteral()
    {
    	EnterRule_HexLiteral();
    	EnterRule("HexLiteral", 90);
    	TraceIn("HexLiteral", 90);
    		try
    		{
    		int _type = HexLiteral;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1078:12: ( '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1078:14: '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )?
    		{
    		DebugLocation(1078, 14);
    		Match('0'); 
    		DebugLocation(1078, 18);
    		if (input.LA(1)=='X'||input.LA(1)=='x')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(1078, 28);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1078:28: ( HexDigit )+
    		int cnt1=0;
    		try { DebugEnterSubRule(1);
    		while (true)
    		{
    			int alt1=2;
    			try { DebugEnterDecision(1, decisionCanBacktrack[1]);
    			int LA1_1 = input.LA(1);

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


    			} finally { DebugExitDecision(1); }
    			switch (alt1)
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1078:28: HexDigit
    				{
    				DebugLocation(1078, 28);
    				mHexDigit(); 

    				}
    				break;

    			default:
    				if (cnt1 >= 1)
    					goto loop1;

    				EarlyExitException eee1 = new EarlyExitException( 1, input );
    				DebugRecognitionException(eee1);
    				throw eee1;
    			}
    			cnt1++;
    		}
    		loop1:
    			;

    		} finally { DebugExitSubRule(1); }

    		DebugLocation(1078, 38);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1078:38: ( IntegerTypeSuffix )?
    		int alt2=2;
    		try { DebugEnterSubRule(2);
    		try { DebugEnterDecision(2, decisionCanBacktrack[2]);
    		int LA2_1 = input.LA(1);

    		if ((LA2_1=='L'||LA2_1=='l'))
    		{
    			alt2 = 1;
    		}
    		} finally { DebugExitDecision(2); }
    		switch (alt2)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1078:38: IntegerTypeSuffix
    			{
    			DebugLocation(1078, 38);
    			mIntegerTypeSuffix(); 

    			}
    			break;

    		}
    		} finally { DebugExitSubRule(2); }

    		DebugLocation(1078, 57);
    		charCount++;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("HexLiteral", 90);
    		LeaveRule("HexLiteral", 90);
    		LeaveRule_HexLiteral();
        }
    }
    // $ANTLR end "HexLiteral"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_DecimalLiteral() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_DecimalLiteral() {}

    // $ANTLR start "DecimalLiteral"
    [GrammarRule("DecimalLiteral")]
    private void mDecimalLiteral()
    {
    	EnterRule_DecimalLiteral();
    	EnterRule("DecimalLiteral", 91);
    	TraceIn("DecimalLiteral", 91);
    		try
    		{
    		int _type = DecimalLiteral;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1080:16: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1080:18: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )?
    		{
    		DebugLocation(1080, 18);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1080:18: ( '0' | '1' .. '9' ( '0' .. '9' )* )
    		int alt4=2;
    		try { DebugEnterSubRule(4);
    		try { DebugEnterDecision(4, decisionCanBacktrack[4]);
    		int LA4_1 = input.LA(1);

    		if ((LA4_1=='0'))
    		{
    			alt4 = 1;
    		}
    		else if (((LA4_1>='1' && LA4_1<='9')))
    		{
    			alt4 = 2;
    		}

    		else
    		{
    			NoViableAltException nvae = new NoViableAltException("", 4, 0, input, 1);
    			DebugRecognitionException(nvae);
    			throw nvae;
    		}

    		} finally { DebugExitDecision(4); }
    		switch (alt4)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1080:19: '0'
    			{
    			DebugLocation(1080, 19);
    			Match('0'); 

    			}
    			break;
    		case 2:
    			DebugEnterAlt(2);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1080:25: '1' .. '9' ( '0' .. '9' )*
    			{
    			DebugLocation(1080, 25);
    			MatchRange('1','9'); 
    			DebugLocation(1080, 34);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1080:34: ( '0' .. '9' )*
    			try { DebugEnterSubRule(3);
    			while (true)
    			{
    				int alt3=2;
    				try { DebugEnterDecision(3, decisionCanBacktrack[3]);
    				int LA3_1 = input.LA(1);

    				if (((LA3_1>='0' && LA3_1<='9')))
    				{
    					alt3 = 1;
    				}


    				} finally { DebugExitDecision(3); }
    				switch ( alt3 )
    				{
    				case 1:
    					DebugEnterAlt(1);
    					// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    					{
    					DebugLocation(1080, 34);
    					input.Consume();


    					}
    					break;

    				default:
    					goto loop3;
    				}
    			}

    			loop3:
    				;

    			} finally { DebugExitSubRule(3); }


    			}
    			break;

    		}
    		} finally { DebugExitSubRule(4); }

    		DebugLocation(1080, 45);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1080:45: ( IntegerTypeSuffix )?
    		int alt5=2;
    		try { DebugEnterSubRule(5);
    		try { DebugEnterDecision(5, decisionCanBacktrack[5]);
    		int LA5_1 = input.LA(1);

    		if ((LA5_1=='L'||LA5_1=='l'))
    		{
    			alt5 = 1;
    		}
    		} finally { DebugExitDecision(5); }
    		switch (alt5)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1080:45: IntegerTypeSuffix
    			{
    			DebugLocation(1080, 45);
    			mIntegerTypeSuffix(); 

    			}
    			break;

    		}
    		} finally { DebugExitSubRule(5); }

    		DebugLocation(1080, 64);
    		charCount++;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("DecimalLiteral", 91);
    		LeaveRule("DecimalLiteral", 91);
    		LeaveRule_DecimalLiteral();
        }
    }
    // $ANTLR end "DecimalLiteral"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_OctalLiteral() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_OctalLiteral() {}

    // $ANTLR start "OctalLiteral"
    [GrammarRule("OctalLiteral")]
    private void mOctalLiteral()
    {
    	EnterRule_OctalLiteral();
    	EnterRule("OctalLiteral", 92);
    	TraceIn("OctalLiteral", 92);
    		try
    		{
    		int _type = OctalLiteral;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1082:14: ( '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1082:16: '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )?
    		{
    		DebugLocation(1082, 16);
    		Match('0'); 
    		DebugLocation(1082, 20);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1082:20: ( '0' .. '7' )+
    		int cnt6=0;
    		try { DebugEnterSubRule(6);
    		while (true)
    		{
    			int alt6=2;
    			try { DebugEnterDecision(6, decisionCanBacktrack[6]);
    			int LA6_1 = input.LA(1);

    			if (((LA6_1>='0' && LA6_1<='7')))
    			{
    				alt6 = 1;
    			}


    			} finally { DebugExitDecision(6); }
    			switch (alt6)
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    				{
    				DebugLocation(1082, 20);
    				input.Consume();


    				}
    				break;

    			default:
    				if (cnt6 >= 1)
    					goto loop6;

    				EarlyExitException eee6 = new EarlyExitException( 6, input );
    				DebugRecognitionException(eee6);
    				throw eee6;
    			}
    			cnt6++;
    		}
    		loop6:
    			;

    		} finally { DebugExitSubRule(6); }

    		DebugLocation(1082, 32);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1082:32: ( IntegerTypeSuffix )?
    		int alt7=2;
    		try { DebugEnterSubRule(7);
    		try { DebugEnterDecision(7, decisionCanBacktrack[7]);
    		int LA7_1 = input.LA(1);

    		if ((LA7_1=='L'||LA7_1=='l'))
    		{
    			alt7 = 1;
    		}
    		} finally { DebugExitDecision(7); }
    		switch (alt7)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1082:32: IntegerTypeSuffix
    			{
    			DebugLocation(1082, 32);
    			mIntegerTypeSuffix(); 

    			}
    			break;

    		}
    		} finally { DebugExitSubRule(7); }

    		DebugLocation(1082, 51);
    		charCount++;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("OctalLiteral", 92);
    		LeaveRule("OctalLiteral", 92);
    		LeaveRule_OctalLiteral();
        }
    }
    // $ANTLR end "OctalLiteral"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_HexDigit() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_HexDigit() {}

    // $ANTLR start "HexDigit"
    [GrammarRule("HexDigit")]
    private void mHexDigit()
    {
    	EnterRule_HexDigit();
    	EnterRule("HexDigit", 93);
    	TraceIn("HexDigit", 93);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1086:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1086:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
    		{
    		DebugLocation(1086, 12);
    		if ((input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f'))
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(1086, 41);
    		charCount++;

    		}

    	}
    	finally
    	{
    		TraceOut("HexDigit", 93);
    		LeaveRule("HexDigit", 93);
    		LeaveRule_HexDigit();
        }
    }
    // $ANTLR end "HexDigit"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_IntegerTypeSuffix() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_IntegerTypeSuffix() {}

    // $ANTLR start "IntegerTypeSuffix"
    [GrammarRule("IntegerTypeSuffix")]
    private void mIntegerTypeSuffix()
    {
    	EnterRule_IntegerTypeSuffix();
    	EnterRule("IntegerTypeSuffix", 94);
    	TraceIn("IntegerTypeSuffix", 94);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1089:19: ( ( 'l' | 'L' ) )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1089:21: ( 'l' | 'L' )
    		{
    		DebugLocation(1089, 21);
    		if (input.LA(1)=='L'||input.LA(1)=='l')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(1089, 31);
    		charCount++;

    		}

    	}
    	finally
    	{
    		TraceOut("IntegerTypeSuffix", 94);
    		LeaveRule("IntegerTypeSuffix", 94);
    		LeaveRule_IntegerTypeSuffix();
        }
    }
    // $ANTLR end "IntegerTypeSuffix"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_FloatingPointLiteral() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_FloatingPointLiteral() {}

    // $ANTLR start "FloatingPointLiteral"
    [GrammarRule("FloatingPointLiteral")]
    private void mFloatingPointLiteral()
    {
    	EnterRule_FloatingPointLiteral();
    	EnterRule("FloatingPointLiteral", 95);
    	TraceIn("FloatingPointLiteral", 95);
    		try
    		{
    		int _type = FloatingPointLiteral;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1091:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | ( '0' .. '9' )+ FloatTypeSuffix )
    		int alt18=4;
    		try { DebugEnterDecision(18, decisionCanBacktrack[18]);
    		try
    		{
    			alt18 = dfa18.Predict(input);
    		}
    		catch (NoViableAltException nvae)
    		{
    			DebugRecognitionException(nvae);
    			throw;
    		}
    		} finally { DebugExitDecision(18); }
    		switch (alt18)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1091:9: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )?
    			{
    			DebugLocation(1091, 9);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1091:9: ( '0' .. '9' )+
    			int cnt8=0;
    			try { DebugEnterSubRule(8);
    			while (true)
    			{
    				int alt8=2;
    				try { DebugEnterDecision(8, decisionCanBacktrack[8]);
    				int LA8_1 = input.LA(1);

    				if (((LA8_1>='0' && LA8_1<='9')))
    				{
    					alt8 = 1;
    				}


    				} finally { DebugExitDecision(8); }
    				switch (alt8)
    				{
    				case 1:
    					DebugEnterAlt(1);
    					// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    					{
    					DebugLocation(1091, 9);
    					input.Consume();


    					}
    					break;

    				default:
    					if (cnt8 >= 1)
    						goto loop8;

    					EarlyExitException eee8 = new EarlyExitException( 8, input );
    					DebugRecognitionException(eee8);
    					throw eee8;
    				}
    				cnt8++;
    			}
    			loop8:
    				;

    			} finally { DebugExitSubRule(8); }

    			DebugLocation(1091, 21);
    			Match('.'); 
    			DebugLocation(1091, 25);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1091:25: ( '0' .. '9' )*
    			try { DebugEnterSubRule(9);
    			while (true)
    			{
    				int alt9=2;
    				try { DebugEnterDecision(9, decisionCanBacktrack[9]);
    				int LA9_1 = input.LA(1);

    				if (((LA9_1>='0' && LA9_1<='9')))
    				{
    					alt9 = 1;
    				}


    				} finally { DebugExitDecision(9); }
    				switch ( alt9 )
    				{
    				case 1:
    					DebugEnterAlt(1);
    					// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    					{
    					DebugLocation(1091, 25);
    					input.Consume();


    					}
    					break;

    				default:
    					goto loop9;
    				}
    			}

    			loop9:
    				;

    			} finally { DebugExitSubRule(9); }

    			DebugLocation(1091, 37);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1091:37: ( Exponent )?
    			int alt10=2;
    			try { DebugEnterSubRule(10);
    			try { DebugEnterDecision(10, decisionCanBacktrack[10]);
    			int LA10_1 = input.LA(1);

    			if ((LA10_1=='E'||LA10_1=='e'))
    			{
    				alt10 = 1;
    			}
    			} finally { DebugExitDecision(10); }
    			switch (alt10)
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1091:37: Exponent
    				{
    				DebugLocation(1091, 37);
    				mExponent(); 

    				}
    				break;

    			}
    			} finally { DebugExitSubRule(10); }

    			DebugLocation(1091, 47);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1091:47: ( FloatTypeSuffix )?
    			int alt11=2;
    			try { DebugEnterSubRule(11);
    			try { DebugEnterDecision(11, decisionCanBacktrack[11]);
    			int LA11_1 = input.LA(1);

    			if ((LA11_1=='D'||LA11_1=='F'||LA11_1=='d'||LA11_1=='f'))
    			{
    				alt11 = 1;
    			}
    			} finally { DebugExitDecision(11); }
    			switch (alt11)
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1091:47: FloatTypeSuffix
    				{
    				DebugLocation(1091, 47);
    				mFloatTypeSuffix(); 

    				}
    				break;

    			}
    			} finally { DebugExitSubRule(11); }

    			DebugLocation(1091, 64);
    			charCount++;

    			}
    			break;
    		case 2:
    			DebugEnterAlt(2);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1092:9: '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )?
    			{
    			DebugLocation(1092, 9);
    			Match('.'); 
    			DebugLocation(1092, 13);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1092:13: ( '0' .. '9' )+
    			int cnt12=0;
    			try { DebugEnterSubRule(12);
    			while (true)
    			{
    				int alt12=2;
    				try { DebugEnterDecision(12, decisionCanBacktrack[12]);
    				int LA12_1 = input.LA(1);

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


    				} finally { DebugExitDecision(12); }
    				switch (alt12)
    				{
    				case 1:
    					DebugEnterAlt(1);
    					// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    					{
    					DebugLocation(1092, 13);
    					input.Consume();


    					}
    					break;

    				default:
    					if (cnt12 >= 1)
    						goto loop12;

    					EarlyExitException eee12 = new EarlyExitException( 12, input );
    					DebugRecognitionException(eee12);
    					throw eee12;
    				}
    				cnt12++;
    			}
    			loop12:
    				;

    			} finally { DebugExitSubRule(12); }

    			DebugLocation(1092, 25);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1092:25: ( Exponent )?
    			int alt13=2;
    			try { DebugEnterSubRule(13);
    			try { DebugEnterDecision(13, decisionCanBacktrack[13]);
    			int LA13_1 = input.LA(1);

    			if ((LA13_1=='E'||LA13_1=='e'))
    			{
    				alt13 = 1;
    			}
    			} finally { DebugExitDecision(13); }
    			switch (alt13)
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1092:25: Exponent
    				{
    				DebugLocation(1092, 25);
    				mExponent(); 

    				}
    				break;

    			}
    			} finally { DebugExitSubRule(13); }

    			DebugLocation(1092, 35);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1092:35: ( FloatTypeSuffix )?
    			int alt14=2;
    			try { DebugEnterSubRule(14);
    			try { DebugEnterDecision(14, decisionCanBacktrack[14]);
    			int LA14_1 = input.LA(1);

    			if ((LA14_1=='D'||LA14_1=='F'||LA14_1=='d'||LA14_1=='f'))
    			{
    				alt14 = 1;
    			}
    			} finally { DebugExitDecision(14); }
    			switch (alt14)
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1092:35: FloatTypeSuffix
    				{
    				DebugLocation(1092, 35);
    				mFloatTypeSuffix(); 

    				}
    				break;

    			}
    			} finally { DebugExitSubRule(14); }

    			DebugLocation(1092, 52);
    			charCount++;

    			}
    			break;
    		case 3:
    			DebugEnterAlt(3);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1093:9: ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )?
    			{
    			DebugLocation(1093, 9);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1093:9: ( '0' .. '9' )+
    			int cnt15=0;
    			try { DebugEnterSubRule(15);
    			while (true)
    			{
    				int alt15=2;
    				try { DebugEnterDecision(15, decisionCanBacktrack[15]);
    				int LA15_1 = input.LA(1);

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


    				} finally { DebugExitDecision(15); }
    				switch (alt15)
    				{
    				case 1:
    					DebugEnterAlt(1);
    					// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    					{
    					DebugLocation(1093, 9);
    					input.Consume();


    					}
    					break;

    				default:
    					if (cnt15 >= 1)
    						goto loop15;

    					EarlyExitException eee15 = new EarlyExitException( 15, input );
    					DebugRecognitionException(eee15);
    					throw eee15;
    				}
    				cnt15++;
    			}
    			loop15:
    				;

    			} finally { DebugExitSubRule(15); }

    			DebugLocation(1093, 21);
    			mExponent(); 
    			DebugLocation(1093, 30);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1093:30: ( FloatTypeSuffix )?
    			int alt16=2;
    			try { DebugEnterSubRule(16);
    			try { DebugEnterDecision(16, decisionCanBacktrack[16]);
    			int LA16_1 = input.LA(1);

    			if ((LA16_1=='D'||LA16_1=='F'||LA16_1=='d'||LA16_1=='f'))
    			{
    				alt16 = 1;
    			}
    			} finally { DebugExitDecision(16); }
    			switch (alt16)
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1093:30: FloatTypeSuffix
    				{
    				DebugLocation(1093, 30);
    				mFloatTypeSuffix(); 

    				}
    				break;

    			}
    			} finally { DebugExitSubRule(16); }

    			DebugLocation(1093, 47);
    			charCount++;

    			}
    			break;
    		case 4:
    			DebugEnterAlt(4);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1094:9: ( '0' .. '9' )+ FloatTypeSuffix
    			{
    			DebugLocation(1094, 9);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1094:9: ( '0' .. '9' )+
    			int cnt17=0;
    			try { DebugEnterSubRule(17);
    			while (true)
    			{
    				int alt17=2;
    				try { DebugEnterDecision(17, decisionCanBacktrack[17]);
    				int LA17_1 = input.LA(1);

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


    				} finally { DebugExitDecision(17); }
    				switch (alt17)
    				{
    				case 1:
    					DebugEnterAlt(1);
    					// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    					{
    					DebugLocation(1094, 9);
    					input.Consume();


    					}
    					break;

    				default:
    					if (cnt17 >= 1)
    						goto loop17;

    					EarlyExitException eee17 = new EarlyExitException( 17, input );
    					DebugRecognitionException(eee17);
    					throw eee17;
    				}
    				cnt17++;
    			}
    			loop17:
    				;

    			} finally { DebugExitSubRule(17); }

    			DebugLocation(1094, 21);
    			mFloatTypeSuffix(); 
    			DebugLocation(1094, 37);
    			charCount++;

    			}
    			break;

    		}
    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("FloatingPointLiteral", 95);
    		LeaveRule("FloatingPointLiteral", 95);
    		LeaveRule_FloatingPointLiteral();
        }
    }
    // $ANTLR end "FloatingPointLiteral"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_Exponent() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_Exponent() {}

    // $ANTLR start "Exponent"
    [GrammarRule("Exponent")]
    private void mExponent()
    {
    	EnterRule_Exponent();
    	EnterRule("Exponent", 96);
    	TraceIn("Exponent", 96);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1099:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1099:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+
    		{
    		DebugLocation(1099, 12);
    		if (input.LA(1)=='E'||input.LA(1)=='e')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(1099, 22);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1099:22: ( '+' | '-' )?
    		int alt19=2;
    		try { DebugEnterSubRule(19);
    		try { DebugEnterDecision(19, decisionCanBacktrack[19]);
    		int LA19_1 = input.LA(1);

    		if ((LA19_1=='+'||LA19_1=='-'))
    		{
    			alt19 = 1;
    		}
    		} finally { DebugExitDecision(19); }
    		switch (alt19)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    			{
    			DebugLocation(1099, 22);
    			input.Consume();


    			}
    			break;

    		}
    		} finally { DebugExitSubRule(19); }

    		DebugLocation(1099, 33);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1099:33: ( '0' .. '9' )+
    		int cnt20=0;
    		try { DebugEnterSubRule(20);
    		while (true)
    		{
    			int alt20=2;
    			try { DebugEnterDecision(20, decisionCanBacktrack[20]);
    			int LA20_1 = input.LA(1);

    			if (((LA20_1>='0' && LA20_1<='9')))
    			{
    				alt20 = 1;
    			}


    			} finally { DebugExitDecision(20); }
    			switch (alt20)
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    				{
    				DebugLocation(1099, 33);
    				input.Consume();


    				}
    				break;

    			default:
    				if (cnt20 >= 1)
    					goto loop20;

    				EarlyExitException eee20 = new EarlyExitException( 20, input );
    				DebugRecognitionException(eee20);
    				throw eee20;
    			}
    			cnt20++;
    		}
    		loop20:
    			;

    		} finally { DebugExitSubRule(20); }

    		DebugLocation(1099, 45);
    		charCount++;

    		}

    	}
    	finally
    	{
    		TraceOut("Exponent", 96);
    		LeaveRule("Exponent", 96);
    		LeaveRule_Exponent();
        }
    }
    // $ANTLR end "Exponent"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_FloatTypeSuffix() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_FloatTypeSuffix() {}

    // $ANTLR start "FloatTypeSuffix"
    [GrammarRule("FloatTypeSuffix")]
    private void mFloatTypeSuffix()
    {
    	EnterRule_FloatTypeSuffix();
    	EnterRule("FloatTypeSuffix", 97);
    	TraceIn("FloatTypeSuffix", 97);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1102:17: ( ( 'f' | 'F' | 'd' | 'D' ) )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1102:19: ( 'f' | 'F' | 'd' | 'D' )
    		{
    		DebugLocation(1102, 19);
    		if (input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='d'||input.LA(1)=='f')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(1102, 37);
    		charCount++;

    		}

    	}
    	finally
    	{
    		TraceOut("FloatTypeSuffix", 97);
    		LeaveRule("FloatTypeSuffix", 97);
    		LeaveRule_FloatTypeSuffix();
        }
    }
    // $ANTLR end "FloatTypeSuffix"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_CharacterLiteral() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_CharacterLiteral() {}

    // $ANTLR start "CharacterLiteral"
    [GrammarRule("CharacterLiteral")]
    private void mCharacterLiteral()
    {
    	EnterRule_CharacterLiteral();
    	EnterRule("CharacterLiteral", 98);
    	TraceIn("CharacterLiteral", 98);
    		try
    		{
    		int _type = CharacterLiteral;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1104:5: ( '\\'' ( EscapeSequence |~ ( '\\'' | '\\\\' ) ) '\\'' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1104:9: '\\'' ( EscapeSequence |~ ( '\\'' | '\\\\' ) ) '\\''
    		{
    		DebugLocation(1104, 9);
    		Match('\''); 
    		DebugLocation(1104, 14);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1104:14: ( EscapeSequence |~ ( '\\'' | '\\\\' ) )
    		int alt21=2;
    		try { DebugEnterSubRule(21);
    		try { DebugEnterDecision(21, decisionCanBacktrack[21]);
    		int LA21_1 = input.LA(1);

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

    		else
    		{
    			NoViableAltException nvae = new NoViableAltException("", 21, 0, input, 1);
    			DebugRecognitionException(nvae);
    			throw nvae;
    		}

    		} finally { DebugExitDecision(21); }
    		switch (alt21)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1104:16: EscapeSequence
    			{
    			DebugLocation(1104, 16);
    			mEscapeSequence(); 

    			}
    			break;
    		case 2:
    			DebugEnterAlt(2);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1104:33: ~ ( '\\'' | '\\\\' )
    			{
    			DebugLocation(1104, 33);
    			input.Consume();


    			}
    			break;

    		}
    		} finally { DebugExitSubRule(21); }

    		DebugLocation(1104, 48);
    		Match('\''); 
    		DebugLocation(1104, 53);
    		charCount++;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("CharacterLiteral", 98);
    		LeaveRule("CharacterLiteral", 98);
    		LeaveRule_CharacterLiteral();
        }
    }
    // $ANTLR end "CharacterLiteral"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_StringLiteral() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_StringLiteral() {}

    // $ANTLR start "StringLiteral"
    [GrammarRule("StringLiteral")]
    private void mStringLiteral()
    {
    	EnterRule_StringLiteral();
    	EnterRule("StringLiteral", 99);
    	TraceIn("StringLiteral", 99);
    		try
    		{
    		int _type = StringLiteral;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1108:5: ( '\"' ( EscapeSequence |~ ( '\\\\' | '\"' ) )* '\"' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1108:8: '\"' ( EscapeSequence |~ ( '\\\\' | '\"' ) )* '\"'
    		{
    		DebugLocation(1108, 8);
    		Match('\"'); 
    		DebugLocation(1108, 12);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1108:12: ( EscapeSequence |~ ( '\\\\' | '\"' ) )*
    		try { DebugEnterSubRule(22);
    		while (true)
    		{
    			int alt22=3;
    			try { DebugEnterDecision(22, decisionCanBacktrack[22]);
    			int LA22_1 = input.LA(1);

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


    			} finally { DebugExitDecision(22); }
    			switch ( alt22 )
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1108:14: EscapeSequence
    				{
    				DebugLocation(1108, 14);
    				mEscapeSequence(); 

    				}
    				break;
    			case 2:
    				DebugEnterAlt(2);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1108:31: ~ ( '\\\\' | '\"' )
    				{
    				DebugLocation(1108, 31);
    				input.Consume();


    				}
    				break;

    			default:
    				goto loop22;
    			}
    		}

    		loop22:
    			;

    		} finally { DebugExitSubRule(22); }

    		DebugLocation(1108, 46);
    		Match('\"'); 
    		DebugLocation(1108, 50);
    		charCount++;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("StringLiteral", 99);
    		LeaveRule("StringLiteral", 99);
    		LeaveRule_StringLiteral();
        }
    }
    // $ANTLR end "StringLiteral"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_EscapeSequence() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_EscapeSequence() {}

    // $ANTLR start "EscapeSequence"
    [GrammarRule("EscapeSequence")]
    private void mEscapeSequence()
    {
    	EnterRule_EscapeSequence();
    	EnterRule("EscapeSequence", 100);
    	TraceIn("EscapeSequence", 100);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1114:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UnicodeEscape | OctalEscape )
    		int alt23=3;
    		try { DebugEnterDecision(23, decisionCanBacktrack[23]);
    		int LA23_1 = input.LA(1);

    		if ((LA23_1=='\\'))
    		{
    			switch (input.LA(2))
    			{
    			case '\"':
    			case '\'':
    			case '\\':
    			case 'b':
    			case 'f':
    			case 'n':
    			case 'r':
    			case 't':
    				{
    				alt23 = 1;
    				}
    				break;
    			case 'u':
    				{
    				alt23 = 2;
    				}
    				break;
    			case '0':
    			case '1':
    			case '2':
    			case '3':
    			case '4':
    			case '5':
    			case '6':
    			case '7':
    				{
    				alt23 = 3;
    				}
    				break;
    			default:
    				{
    					NoViableAltException nvae = new NoViableAltException("", 23, 1, input, 2);
    					DebugRecognitionException(nvae);
    					throw nvae;
    				}
    			}

    		}

    		else
    		{
    			NoViableAltException nvae = new NoViableAltException("", 23, 0, input, 1);
    			DebugRecognitionException(nvae);
    			throw nvae;
    		}

    		} finally { DebugExitDecision(23); }
    		switch (alt23)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1114:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
    			{
    			DebugLocation(1114, 9);
    			Match('\\'); 
    			DebugLocation(1114, 14);
    			input.Consume();

    			DebugLocation(1114, 51);
    			charCount++;

    			}
    			break;
    		case 2:
    			DebugEnterAlt(2);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1115:9: UnicodeEscape
    			{
    			DebugLocation(1115, 9);
    			mUnicodeEscape(); 
    			DebugLocation(1115, 23);
    			charCount++;

    			}
    			break;
    		case 3:
    			DebugEnterAlt(3);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1116:9: OctalEscape
    			{
    			DebugLocation(1116, 9);
    			mOctalEscape(); 
    			DebugLocation(1116, 21);
    			charCount++;

    			}
    			break;

    		}
    	}
    	finally
    	{
    		TraceOut("EscapeSequence", 100);
    		LeaveRule("EscapeSequence", 100);
    		LeaveRule_EscapeSequence();
        }
    }
    // $ANTLR end "EscapeSequence"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_OctalEscape() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_OctalEscape() {}

    // $ANTLR start "OctalEscape"
    [GrammarRule("OctalEscape")]
    private void mOctalEscape()
    {
    	EnterRule_OctalEscape();
    	EnterRule("OctalEscape", 101);
    	TraceIn("OctalEscape", 101);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1121:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )
    		int alt24=3;
    		try { DebugEnterDecision(24, decisionCanBacktrack[24]);
    		int LA24_1 = input.LA(1);

    		if ((LA24_1=='\\'))
    		{
    			int LA24_2 = input.LA(2);

    			if (((LA24_2>='0' && LA24_2<='3')))
    			{
    				int LA24_3 = input.LA(3);

    				if (((LA24_3>='0' && LA24_3<='7')))
    				{
    					int LA24_4 = input.LA(4);

    					if (((LA24_4>='0' && LA24_4<='7')))
    					{
    						alt24 = 1;
    					}

    					else
    					{
    						alt24 = 2;
    					}

    				}

    				else
    				{
    					alt24 = 3;
    				}

    			}
    			else if (((LA24_2>='4' && LA24_2<='7')))
    			{
    				int LA24_3 = input.LA(3);

    				if (((LA24_3>='0' && LA24_3<='7')))
    				{
    					alt24 = 2;
    				}

    				else
    				{
    					alt24 = 3;
    				}

    			}

    			else
    			{
    				NoViableAltException nvae = new NoViableAltException("", 24, 1, input, 2);
    				DebugRecognitionException(nvae);
    				throw nvae;
    			}

    		}

    		else
    		{
    			NoViableAltException nvae = new NoViableAltException("", 24, 0, input, 1);
    			DebugRecognitionException(nvae);
    			throw nvae;
    		}

    		} finally { DebugExitDecision(24); }
    		switch (alt24)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1121:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )
    			{
    			DebugLocation(1121, 9);
    			Match('\\'); 
    			DebugLocation(1121, 14);
    			input.Consume();

    			DebugLocation(1121, 25);
    			input.Consume();

    			DebugLocation(1121, 36);
    			input.Consume();

    			DebugLocation(1121, 47);
    			charCount++;

    			}
    			break;
    		case 2:
    			DebugEnterAlt(2);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1122:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )
    			{
    			DebugLocation(1122, 9);
    			Match('\\'); 
    			DebugLocation(1122, 14);
    			input.Consume();

    			DebugLocation(1122, 25);
    			input.Consume();

    			DebugLocation(1122, 36);
    			charCount++;

    			}
    			break;
    		case 3:
    			DebugEnterAlt(3);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1123:9: '\\\\' ( '0' .. '7' )
    			{
    			DebugLocation(1123, 9);
    			Match('\\'); 
    			DebugLocation(1123, 14);
    			input.Consume();

    			DebugLocation(1123, 25);
    			charCount++;

    			}
    			break;

    		}
    	}
    	finally
    	{
    		TraceOut("OctalEscape", 101);
    		LeaveRule("OctalEscape", 101);
    		LeaveRule_OctalEscape();
        }
    }
    // $ANTLR end "OctalEscape"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_UnicodeEscape() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_UnicodeEscape() {}

    // $ANTLR start "UnicodeEscape"
    [GrammarRule("UnicodeEscape")]
    private void mUnicodeEscape()
    {
    	EnterRule_UnicodeEscape();
    	EnterRule("UnicodeEscape", 102);
    	TraceIn("UnicodeEscape", 102);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1128:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1128:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit
    		{
    		DebugLocation(1128, 9);
    		Match('\\'); 
    		DebugLocation(1128, 14);
    		Match('u'); 
    		DebugLocation(1128, 18);
    		mHexDigit(); 
    		DebugLocation(1128, 27);
    		mHexDigit(); 
    		DebugLocation(1128, 36);
    		mHexDigit(); 
    		DebugLocation(1128, 45);
    		mHexDigit(); 
    		DebugLocation(1128, 54);
    		charCount++;

    		}

    	}
    	finally
    	{
    		TraceOut("UnicodeEscape", 102);
    		LeaveRule("UnicodeEscape", 102);
    		LeaveRule_UnicodeEscape();
        }
    }
    // $ANTLR end "UnicodeEscape"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_ENUM() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_ENUM() {}

    // $ANTLR start "ENUM"
    [GrammarRule("ENUM")]
    private void mENUM()
    {
    	EnterRule_ENUM();
    	EnterRule("ENUM", 103);
    	TraceIn("ENUM", 103);
    		try
    		{
    		int _type = ENUM;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1130:5: ( 'enum' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1130:9: 'enum'
    		{
    		DebugLocation(1130, 9);
    		Match("enum"); 

    		DebugLocation(1130, 16);
    		if (!enumIsKeyword) _type=Identifier;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("ENUM", 103);
    		LeaveRule("ENUM", 103);
    		LeaveRule_ENUM();
        }
    }
    // $ANTLR end "ENUM"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_ASSERT() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_ASSERT() {}

    // $ANTLR start "ASSERT"
    [GrammarRule("ASSERT")]
    private void mASSERT()
    {
    	EnterRule_ASSERT();
    	EnterRule("ASSERT", 104);
    	TraceIn("ASSERT", 104);
    		try
    		{
    		int _type = ASSERT;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1134:5: ( 'assert' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1134:9: 'assert'
    		{
    		DebugLocation(1134, 9);
    		Match("assert"); 

    		DebugLocation(1134, 18);
    		if (!assertIsKeyword) _type=Identifier;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("ASSERT", 104);
    		LeaveRule("ASSERT", 104);
    		LeaveRule_ASSERT();
        }
    }
    // $ANTLR end "ASSERT"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_Identifier() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_Identifier() {}

    // $ANTLR start "Identifier"
    [GrammarRule("Identifier")]
    private void mIdentifier()
    {
    	EnterRule_Identifier();
    	EnterRule("Identifier", 105);
    	TraceIn("Identifier", 105);
    		try
    		{
    		int _type = Identifier;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1138:5: ( Letter ( Letter | JavaIDDigit )* )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1138:9: Letter ( Letter | JavaIDDigit )*
    		{
    		DebugLocation(1138, 9);
    		mLetter(); 
    		DebugLocation(1138, 16);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1138:16: ( Letter | JavaIDDigit )*
    		try { DebugEnterSubRule(25);
    		while (true)
    		{
    			int alt25=3;
    			try { DebugEnterDecision(25, decisionCanBacktrack[25]);
    			int LA25_1 = input.LA(1);

    			if ((LA25_1=='$'||(LA25_1>='A' && LA25_1<='Z')||LA25_1=='_'||(LA25_1>='a' && LA25_1<='z')||(LA25_1>='\u00C0' && LA25_1<='\u00D6')||(LA25_1>='\u00D8' && LA25_1<='\u00F6')||(LA25_1>='\u00F8' && LA25_1<='\u00FF')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0660' && LA25_1<='\u0669')||(LA25_1>='\u3040' && LA25_1<='\u318F')||(LA25_1>='\u3300' && LA25_1<='\u337F')||(LA25_1>='\u3400' && LA25_1<='\u3D2D')||(LA25_1>='\u4E00' && LA25_1<='\u9FFF')||(LA25_1>='\uF900' && LA25_1<='\uFAFF')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='0' && LA25_1<='9')))
    			{
    				alt25 = 2;
    			}
    			else if (((LA25_1>='\u06F0' && LA25_1<='\u06F9')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0966' && LA25_1<='\u096F')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u09E6' && LA25_1<='\u09EF')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0A66' && LA25_1<='\u0A6F')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0AE6' && LA25_1<='\u0AEF')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0B66' && LA25_1<='\u0B6F')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0BE7' && LA25_1<='\u0BEF')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0C66' && LA25_1<='\u0C6F')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0CE6' && LA25_1<='\u0CEF')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0D66' && LA25_1<='\u0D6F')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0E50' && LA25_1<='\u0E59')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0ED0' && LA25_1<='\u0ED9')))
    			{
    				alt25 = 1;
    			}
    			else if (((LA25_1>='\u0100' && LA25_1<='\u065F')||(LA25_1>='\u066A' && LA25_1<='\u06EF')||(LA25_1>='\u06FA' && LA25_1<='\u0965')||(LA25_1>='\u0970' && LA25_1<='\u09E5')||(LA25_1>='\u09F0' && LA25_1<='\u0A65')||(LA25_1>='\u0A70' && LA25_1<='\u0AE5')||(LA25_1>='\u0AF0' && LA25_1<='\u0B65')||(LA25_1>='\u0B70' && LA25_1<='\u0BE6')||(LA25_1>='\u0BF0' && LA25_1<='\u0C65')||(LA25_1>='\u0C70' && LA25_1<='\u0CE5')||(LA25_1>='\u0CF0' && LA25_1<='\u0D65')||(LA25_1>='\u0D70' && LA25_1<='\u0E4F')||(LA25_1>='\u0E5A' && LA25_1<='\u0ECF')||(LA25_1>='\u0EDA' && LA25_1<='\u1FFF')))
    			{
    				alt25 = 1;
    			}


    			} finally { DebugExitDecision(25); }
    			switch ( alt25 )
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1138:17: Letter
    				{
    				DebugLocation(1138, 17);
    				mLetter(); 

    				}
    				break;
    			case 2:
    				DebugEnterAlt(2);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1138:24: JavaIDDigit
    				{
    				DebugLocation(1138, 24);
    				mJavaIDDigit(); 
    				DebugLocation(1138, 36);
    				charCount++;

    				}
    				break;

    			default:
    				goto loop25;
    			}
    		}

    		loop25:
    			;

    		} finally { DebugExitSubRule(25); }


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("Identifier", 105);
    		LeaveRule("Identifier", 105);
    		LeaveRule_Identifier();
        }
    }
    // $ANTLR end "Identifier"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_Letter() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_Letter() {}

    // $ANTLR start "Letter"
    [GrammarRule("Letter")]
    private void mLetter()
    {
    	EnterRule_Letter();
    	EnterRule("Letter", 106);
    	TraceIn("Letter", 106);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1150:5: ( '\\u0024' | '\\u0041' .. '\\u005a' | '\\u005f' | '\\u0061' .. '\\u007a' | '\\u00c0' .. '\\u00d6' | '\\u00d8' .. '\\u00f6' | '\\u00f8' .. '\\u00ff' | '\\u0100' .. '\\u1fff' | '\\u3040' .. '\\u318f' | '\\u3300' .. '\\u337f' | '\\u3400' .. '\\u3d2d' | '\\u4e00' .. '\\u9fff' | '\\uf900' .. '\\ufaff' )
    		int alt26=13;
    		try { DebugEnterDecision(26, decisionCanBacktrack[26]);
    		int LA26_1 = input.LA(1);

    		if ((LA26_1=='$'))
    		{
    			alt26 = 1;
    		}
    		else if (((LA26_1>='A' && LA26_1<='Z')))
    		{
    			alt26 = 2;
    		}
    		else if ((LA26_1=='_'))
    		{
    			alt26 = 3;
    		}
    		else if (((LA26_1>='a' && LA26_1<='z')))
    		{
    			alt26 = 4;
    		}
    		else if (((LA26_1>='\u00C0' && LA26_1<='\u00D6')))
    		{
    			alt26 = 5;
    		}
    		else if (((LA26_1>='\u00D8' && LA26_1<='\u00F6')))
    		{
    			alt26 = 6;
    		}
    		else if (((LA26_1>='\u00F8' && LA26_1<='\u00FF')))
    		{
    			alt26 = 7;
    		}
    		else if (((LA26_1>='\u0100' && LA26_1<='\u1FFF')))
    		{
    			alt26 = 8;
    		}
    		else if (((LA26_1>='\u3040' && LA26_1<='\u318F')))
    		{
    			alt26 = 9;
    		}
    		else if (((LA26_1>='\u3300' && LA26_1<='\u337F')))
    		{
    			alt26 = 10;
    		}
    		else if (((LA26_1>='\u3400' && LA26_1<='\u3D2D')))
    		{
    			alt26 = 11;
    		}
    		else if (((LA26_1>='\u4E00' && LA26_1<='\u9FFF')))
    		{
    			alt26 = 12;
    		}
    		else if (((LA26_1>='\uF900' && LA26_1<='\uFAFF')))
    		{
    			alt26 = 13;
    		}

    		else
    		{
    			NoViableAltException nvae = new NoViableAltException("", 26, 0, input, 1);
    			DebugRecognitionException(nvae);
    			throw nvae;
    		}

    		} finally { DebugExitDecision(26); }
    		switch (alt26)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1150:8: '\\u0024'
    			{
    			DebugLocation(1150, 8);
    			Match('$'); 
    			DebugLocation(1150, 17);
    			charCount++;

    			}
    			break;
    		case 2:
    			DebugEnterAlt(2);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1151:8: '\\u0041' .. '\\u005a'
    			{
    			DebugLocation(1151, 8);
    			MatchRange('A','Z'); 
    			DebugLocation(1151, 27);
    			charCount++;

    			}
    			break;
    		case 3:
    			DebugEnterAlt(3);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1152:8: '\\u005f'
    			{
    			DebugLocation(1152, 8);
    			Match('_'); 
    			DebugLocation(1152, 17);
    			charCount++;

    			}
    			break;
    		case 4:
    			DebugEnterAlt(4);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1153:8: '\\u0061' .. '\\u007a'
    			{
    			DebugLocation(1153, 8);
    			MatchRange('a','z'); 
    			DebugLocation(1153, 27);
    			charCount++;

    			}
    			break;
    		case 5:
    			DebugEnterAlt(5);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1154:8: '\\u00c0' .. '\\u00d6'
    			{
    			DebugLocation(1154, 8);
    			MatchRange('\u00C0','\u00D6'); 
    			DebugLocation(1154, 27);
    			charCount++;

    			}
    			break;
    		case 6:
    			DebugEnterAlt(6);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1155:8: '\\u00d8' .. '\\u00f6'
    			{
    			DebugLocation(1155, 8);
    			MatchRange('\u00D8','\u00F6'); 
    			DebugLocation(1155, 27);
    			charCount++;

    			}
    			break;
    		case 7:
    			DebugEnterAlt(7);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1156:8: '\\u00f8' .. '\\u00ff'
    			{
    			DebugLocation(1156, 8);
    			MatchRange('\u00F8','\u00FF'); 
    			DebugLocation(1156, 27);
    			charCount++;

    			}
    			break;
    		case 8:
    			DebugEnterAlt(8);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1157:8: '\\u0100' .. '\\u1fff'
    			{
    			DebugLocation(1157, 8);
    			MatchRange('\u0100','\u1FFF'); 
    			DebugLocation(1157, 27);
    			charCount++;

    			}
    			break;
    		case 9:
    			DebugEnterAlt(9);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1158:8: '\\u3040' .. '\\u318f'
    			{
    			DebugLocation(1158, 8);
    			MatchRange('\u3040','\u318F'); 
    			DebugLocation(1158, 27);
    			charCount++;

    			}
    			break;
    		case 10:
    			DebugEnterAlt(10);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1159:8: '\\u3300' .. '\\u337f'
    			{
    			DebugLocation(1159, 8);
    			MatchRange('\u3300','\u337F'); 
    			DebugLocation(1159, 27);
    			charCount++;

    			}
    			break;
    		case 11:
    			DebugEnterAlt(11);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1160:8: '\\u3400' .. '\\u3d2d'
    			{
    			DebugLocation(1160, 8);
    			MatchRange('\u3400','\u3D2D'); 
    			DebugLocation(1160, 27);
    			charCount++;

    			}
    			break;
    		case 12:
    			DebugEnterAlt(12);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1161:8: '\\u4e00' .. '\\u9fff'
    			{
    			DebugLocation(1161, 8);
    			MatchRange('\u4E00','\u9FFF'); 
    			DebugLocation(1161, 27);
    			charCount++;

    			}
    			break;
    		case 13:
    			DebugEnterAlt(13);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1162:8: '\\uf900' .. '\\ufaff'
    			{
    			DebugLocation(1162, 8);
    			MatchRange('\uF900','\uFAFF'); 
    			DebugLocation(1162, 27);
    			charCount++;

    			}
    			break;

    		}
    	}
    	finally
    	{
    		TraceOut("Letter", 106);
    		LeaveRule("Letter", 106);
    		LeaveRule_Letter();
        }
    }
    // $ANTLR end "Letter"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_JavaIDDigit() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_JavaIDDigit() {}

    // $ANTLR start "JavaIDDigit"
    [GrammarRule("JavaIDDigit")]
    private void mJavaIDDigit()
    {
    	EnterRule_JavaIDDigit();
    	EnterRule("JavaIDDigit", 107);
    	TraceIn("JavaIDDigit", 107);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1164:5: ( '\\u0030' .. '\\u0039' | '\\u0660' .. '\\u0669' | '\\u06f0' .. '\\u06f9' | '\\u0966' .. '\\u096f' | '\\u09e6' .. '\\u09ef' | '\\u0a66' .. '\\u0a6f' | '\\u0ae6' .. '\\u0aef' | '\\u0b66' .. '\\u0b6f' | '\\u0be7' .. '\\u0bef' | '\\u0c66' .. '\\u0c6f' | '\\u0ce6' .. '\\u0cef' | '\\u0d66' .. '\\u0d6f' | '\\u0e50' .. '\\u0e59' | '\\u0ed0' .. '\\u0ed9' | '\\u1040' .. '\\u1049' )
    		int alt27=15;
    		try { DebugEnterDecision(27, decisionCanBacktrack[27]);
    		switch (input.LA(1))
    		{
    		case '0':
    		case '1':
    		case '2':
    		case '3':
    		case '4':
    		case '5':
    		case '6':
    		case '7':
    		case '8':
    		case '9':
    			{
    			alt27 = 1;
    			}
    			break;
    		case '\u0660':
    		case '\u0661':
    		case '\u0662':
    		case '\u0663':
    		case '\u0664':
    		case '\u0665':
    		case '\u0666':
    		case '\u0667':
    		case '\u0668':
    		case '\u0669':
    			{
    			alt27 = 2;
    			}
    			break;
    		case '\u06F0':
    		case '\u06F1':
    		case '\u06F2':
    		case '\u06F3':
    		case '\u06F4':
    		case '\u06F5':
    		case '\u06F6':
    		case '\u06F7':
    		case '\u06F8':
    		case '\u06F9':
    			{
    			alt27 = 3;
    			}
    			break;
    		case '\u0966':
    		case '\u0967':
    		case '\u0968':
    		case '\u0969':
    		case '\u096A':
    		case '\u096B':
    		case '\u096C':
    		case '\u096D':
    		case '\u096E':
    		case '\u096F':
    			{
    			alt27 = 4;
    			}
    			break;
    		case '\u09E6':
    		case '\u09E7':
    		case '\u09E8':
    		case '\u09E9':
    		case '\u09EA':
    		case '\u09EB':
    		case '\u09EC':
    		case '\u09ED':
    		case '\u09EE':
    		case '\u09EF':
    			{
    			alt27 = 5;
    			}
    			break;
    		case '\u0A66':
    		case '\u0A67':
    		case '\u0A68':
    		case '\u0A69':
    		case '\u0A6A':
    		case '\u0A6B':
    		case '\u0A6C':
    		case '\u0A6D':
    		case '\u0A6E':
    		case '\u0A6F':
    			{
    			alt27 = 6;
    			}
    			break;
    		case '\u0AE6':
    		case '\u0AE7':
    		case '\u0AE8':
    		case '\u0AE9':
    		case '\u0AEA':
    		case '\u0AEB':
    		case '\u0AEC':
    		case '\u0AED':
    		case '\u0AEE':
    		case '\u0AEF':
    			{
    			alt27 = 7;
    			}
    			break;
    		case '\u0B66':
    		case '\u0B67':
    		case '\u0B68':
    		case '\u0B69':
    		case '\u0B6A':
    		case '\u0B6B':
    		case '\u0B6C':
    		case '\u0B6D':
    		case '\u0B6E':
    		case '\u0B6F':
    			{
    			alt27 = 8;
    			}
    			break;
    		case '\u0BE7':
    		case '\u0BE8':
    		case '\u0BE9':
    		case '\u0BEA':
    		case '\u0BEB':
    		case '\u0BEC':
    		case '\u0BED':
    		case '\u0BEE':
    		case '\u0BEF':
    			{
    			alt27 = 9;
    			}
    			break;
    		case '\u0C66':
    		case '\u0C67':
    		case '\u0C68':
    		case '\u0C69':
    		case '\u0C6A':
    		case '\u0C6B':
    		case '\u0C6C':
    		case '\u0C6D':
    		case '\u0C6E':
    		case '\u0C6F':
    			{
    			alt27 = 10;
    			}
    			break;
    		case '\u0CE6':
    		case '\u0CE7':
    		case '\u0CE8':
    		case '\u0CE9':
    		case '\u0CEA':
    		case '\u0CEB':
    		case '\u0CEC':
    		case '\u0CED':
    		case '\u0CEE':
    		case '\u0CEF':
    			{
    			alt27 = 11;
    			}
    			break;
    		case '\u0D66':
    		case '\u0D67':
    		case '\u0D68':
    		case '\u0D69':
    		case '\u0D6A':
    		case '\u0D6B':
    		case '\u0D6C':
    		case '\u0D6D':
    		case '\u0D6E':
    		case '\u0D6F':
    			{
    			alt27 = 12;
    			}
    			break;
    		case '\u0E50':
    		case '\u0E51':
    		case '\u0E52':
    		case '\u0E53':
    		case '\u0E54':
    		case '\u0E55':
    		case '\u0E56':
    		case '\u0E57':
    		case '\u0E58':
    		case '\u0E59':
    			{
    			alt27 = 13;
    			}
    			break;
    		case '\u0ED0':
    		case '\u0ED1':
    		case '\u0ED2':
    		case '\u0ED3':
    		case '\u0ED4':
    		case '\u0ED5':
    		case '\u0ED6':
    		case '\u0ED7':
    		case '\u0ED8':
    		case '\u0ED9':
    			{
    			alt27 = 14;
    			}
    			break;
    		case '\u1040':
    		case '\u1041':
    		case '\u1042':
    		case '\u1043':
    		case '\u1044':
    		case '\u1045':
    		case '\u1046':
    		case '\u1047':
    		case '\u1048':
    		case '\u1049':
    			{
    			alt27 = 15;
    			}
    			break;
    		default:
    			{
    				NoViableAltException nvae = new NoViableAltException("", 27, 0, input, 1);
    				DebugRecognitionException(nvae);
    				throw nvae;
    			}
    		}

    		} finally { DebugExitDecision(27); }
    		switch (alt27)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1164:8: '\\u0030' .. '\\u0039'
    			{
    			DebugLocation(1164, 8);
    			MatchRange('0','9'); 
    			DebugLocation(1164, 27);
    			charCount++;

    			}
    			break;
    		case 2:
    			DebugEnterAlt(2);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1165:8: '\\u0660' .. '\\u0669'
    			{
    			DebugLocation(1165, 8);
    			MatchRange('\u0660','\u0669'); 
    			DebugLocation(1165, 27);
    			charCount++;

    			}
    			break;
    		case 3:
    			DebugEnterAlt(3);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1166:8: '\\u06f0' .. '\\u06f9'
    			{
    			DebugLocation(1166, 8);
    			MatchRange('\u06F0','\u06F9'); 
    			DebugLocation(1166, 27);
    			charCount++;

    			}
    			break;
    		case 4:
    			DebugEnterAlt(4);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1167:8: '\\u0966' .. '\\u096f'
    			{
    			DebugLocation(1167, 8);
    			MatchRange('\u0966','\u096F'); 
    			DebugLocation(1167, 27);
    			charCount++;

    			}
    			break;
    		case 5:
    			DebugEnterAlt(5);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1168:8: '\\u09e6' .. '\\u09ef'
    			{
    			DebugLocation(1168, 8);
    			MatchRange('\u09E6','\u09EF'); 
    			DebugLocation(1168, 27);
    			charCount++;

    			}
    			break;
    		case 6:
    			DebugEnterAlt(6);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1169:8: '\\u0a66' .. '\\u0a6f'
    			{
    			DebugLocation(1169, 8);
    			MatchRange('\u0A66','\u0A6F'); 
    			DebugLocation(1169, 27);
    			charCount++;

    			}
    			break;
    		case 7:
    			DebugEnterAlt(7);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1170:8: '\\u0ae6' .. '\\u0aef'
    			{
    			DebugLocation(1170, 8);
    			MatchRange('\u0AE6','\u0AEF'); 
    			DebugLocation(1170, 27);
    			charCount++;

    			}
    			break;
    		case 8:
    			DebugEnterAlt(8);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1171:8: '\\u0b66' .. '\\u0b6f'
    			{
    			DebugLocation(1171, 8);
    			MatchRange('\u0B66','\u0B6F'); 
    			DebugLocation(1171, 27);
    			charCount++;

    			}
    			break;
    		case 9:
    			DebugEnterAlt(9);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1172:8: '\\u0be7' .. '\\u0bef'
    			{
    			DebugLocation(1172, 8);
    			MatchRange('\u0BE7','\u0BEF'); 
    			DebugLocation(1172, 27);
    			charCount++;

    			}
    			break;
    		case 10:
    			DebugEnterAlt(10);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1173:8: '\\u0c66' .. '\\u0c6f'
    			{
    			DebugLocation(1173, 8);
    			MatchRange('\u0C66','\u0C6F'); 
    			DebugLocation(1173, 27);
    			charCount++;

    			}
    			break;
    		case 11:
    			DebugEnterAlt(11);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1174:8: '\\u0ce6' .. '\\u0cef'
    			{
    			DebugLocation(1174, 8);
    			MatchRange('\u0CE6','\u0CEF'); 
    			DebugLocation(1174, 27);
    			charCount++;

    			}
    			break;
    		case 12:
    			DebugEnterAlt(12);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1175:8: '\\u0d66' .. '\\u0d6f'
    			{
    			DebugLocation(1175, 8);
    			MatchRange('\u0D66','\u0D6F'); 
    			DebugLocation(1175, 27);
    			charCount++;

    			}
    			break;
    		case 13:
    			DebugEnterAlt(13);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1176:8: '\\u0e50' .. '\\u0e59'
    			{
    			DebugLocation(1176, 8);
    			MatchRange('\u0E50','\u0E59'); 
    			DebugLocation(1176, 27);
    			charCount++;

    			}
    			break;
    		case 14:
    			DebugEnterAlt(14);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1177:8: '\\u0ed0' .. '\\u0ed9'
    			{
    			DebugLocation(1177, 8);
    			MatchRange('\u0ED0','\u0ED9'); 
    			DebugLocation(1177, 27);
    			charCount++;

    			}
    			break;
    		case 15:
    			DebugEnterAlt(15);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1178:8: '\\u1040' .. '\\u1049'
    			{
    			DebugLocation(1178, 8);
    			MatchRange('\u1040','\u1049'); 
    			DebugLocation(1178, 27);
    			charCount++;

    			}
    			break;

    		}
    	}
    	finally
    	{
    		TraceOut("JavaIDDigit", 107);
    		LeaveRule("JavaIDDigit", 107);
    		LeaveRule_JavaIDDigit();
        }
    }
    // $ANTLR end "JavaIDDigit"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_WS() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_WS() {}

    // $ANTLR start "WS"
    [GrammarRule("WS")]
    private void mWS()
    {
    	EnterRule_WS();
    	EnterRule("WS", 108);
    	TraceIn("WS", 108);
    		try
    		{
    		int _type = WS;
    		int _channel = DefaultTokenChannel;
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1181:5: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1181:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )
    		{
    		DebugLocation(1181, 8);
    		if ((input.LA(1)>='\t' && input.LA(1)<='\n')||(input.LA(1)>='\f' && input.LA(1)<='\r')||input.LA(1)==' ')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(1181, 38);
    		whiteSpaceCount++; _channel=Hidden;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("WS", 108);
    		LeaveRule("WS", 108);
    		LeaveRule_WS();
        }
    }
    // $ANTLR end "WS"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_Comments() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_Comments() {}

    // $ANTLR start "Comments"
    [GrammarRule("Comments")]
    private void mComments()
    {
    	EnterRule_Comments();
    	EnterRule("Comments", 109);
    	TraceIn("Comments", 109);
    		try
    		{
    		int _type = Comments;
    		int _channel = DefaultTokenChannel;
    		CommonToken COMMENT1 = default(CommonToken);
    		CommonToken LINE_COMMENT2 = default(CommonToken);

    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1185:2: ( COMMENT | LINE_COMMENT )
    		int alt28=2;
    		try { DebugEnterDecision(28, decisionCanBacktrack[28]);
    		int LA28_1 = input.LA(1);

    		if ((LA28_1=='/'))
    		{
    			int LA28_2 = input.LA(2);

    			if ((LA28_2=='*'))
    			{
    				alt28 = 1;
    			}
    			else if ((LA28_2=='/'))
    			{
    				alt28 = 2;
    			}

    			else
    			{
    				NoViableAltException nvae = new NoViableAltException("", 28, 1, input, 2);
    				DebugRecognitionException(nvae);
    				throw nvae;
    			}

    		}

    		else
    		{
    			NoViableAltException nvae = new NoViableAltException("", 28, 0, input, 1);
    			DebugRecognitionException(nvae);
    			throw nvae;
    		}

    		} finally { DebugExitDecision(28); }
    		switch (alt28)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1185:4: COMMENT
    			{
    			DebugLocation(1185, 4);
    			int COMMENT1Start1751 = CharIndex;
    			int COMMENT1StartLine1751 = Line;
    			int COMMENT1StartCharPos1751 = CharPositionInLine;
    			mCOMMENT(); 
    			COMMENT1 = new CommonToken(input, TokenTypes.Invalid, TokenChannels.Default, COMMENT1Start1751, CharIndex-1);
    			COMMENT1.Line = COMMENT1StartLine1751;
    			COMMENT1.CharPositionInLine = COMMENT1StartCharPos1751;
    			DebugLocation(1185, 12);
    			commentsSet.Add(COMMENT1.Text);
    			DebugLocation(1186, 3);
    			_channel=Hidden;

    			}
    			break;
    		case 2:
    			DebugEnterAlt(2);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1187:4: LINE_COMMENT
    			{
    			DebugLocation(1187, 4);
    			int LINE_COMMENT2Start1762 = CharIndex;
    			int LINE_COMMENT2StartLine1762 = Line;
    			int LINE_COMMENT2StartCharPos1762 = CharPositionInLine;
    			mLINE_COMMENT(); 
    			LINE_COMMENT2 = new CommonToken(input, TokenTypes.Invalid, TokenChannels.Default, LINE_COMMENT2Start1762, CharIndex-1);
    			LINE_COMMENT2.Line = LINE_COMMENT2StartLine1762;
    			LINE_COMMENT2.CharPositionInLine = LINE_COMMENT2StartCharPos1762;
    			DebugLocation(1187, 17);
    			commentsSet.Add(LINE_COMMENT2.Text);
    			DebugLocation(1188, 3);
    			_channel=Hidden; 

    			}
    			break;

    		}
    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("Comments", 109);
    		LeaveRule("Comments", 109);
    		LeaveRule_Comments();
        }
    }
    // $ANTLR end "Comments"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_COMMENT() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_COMMENT() {}

    // $ANTLR start "COMMENT"
    [GrammarRule("COMMENT")]
    private void mCOMMENT()
    {
    	EnterRule_COMMENT();
    	EnterRule("COMMENT", 110);
    	TraceIn("COMMENT", 110);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1194:5: ( '/*' ( options {greedy=false; } : . )* '*/' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1194:9: '/*' ( options {greedy=false; } : . )* '*/'
    		{
    		DebugLocation(1194, 9);
    		Match("/*"); 

    		DebugLocation(1194, 14);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1194:14: ( options {greedy=false; } : . )*
    		try { DebugEnterSubRule(29);
    		while (true)
    		{
    			int alt29=2;
    			try { DebugEnterDecision(29, decisionCanBacktrack[29]);
    			int LA29_1 = input.LA(1);

    			if ((LA29_1=='*'))
    			{
    				int LA29_2 = input.LA(2);

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


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


    			} finally { DebugExitDecision(29); }
    			switch ( alt29 )
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1194:42: .
    				{
    				DebugLocation(1194, 42);
    				MatchAny(); 

    				}
    				break;

    			default:
    				goto loop29;
    			}
    		}

    		loop29:
    			;

    		} finally { DebugExitSubRule(29); }

    		DebugLocation(1194, 47);
    		Match("*/"); 


    		}

    	}
    	finally
    	{
    		TraceOut("COMMENT", 110);
    		LeaveRule("COMMENT", 110);
    		LeaveRule_COMMENT();
        }
    }
    // $ANTLR end "COMMENT"

    [Conditional("ANTLR_TRACE")]
    protected virtual void EnterRule_LINE_COMMENT() {}
    [Conditional("ANTLR_TRACE")]
    protected virtual void LeaveRule_LINE_COMMENT() {}

    // $ANTLR start "LINE_COMMENT"
    [GrammarRule("LINE_COMMENT")]
    private void mLINE_COMMENT()
    {
    	EnterRule_LINE_COMMENT();
    	EnterRule("LINE_COMMENT", 111);
    	TraceIn("LINE_COMMENT", 111);
    		try
    		{
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1199:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1199:7: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
    		{
    		DebugLocation(1199, 7);
    		Match("//"); 

    		DebugLocation(1199, 12);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1199:12: (~ ( '\\n' | '\\r' ) )*
    		try { DebugEnterSubRule(30);
    		while (true)
    		{
    			int alt30=2;
    			try { DebugEnterDecision(30, decisionCanBacktrack[30]);
    			int LA30_1 = input.LA(1);

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


    			} finally { DebugExitDecision(30); }
    			switch ( alt30 )
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:
    				{
    				DebugLocation(1199, 12);
    				input.Consume();


    				}
    				break;

    			default:
    				goto loop30;
    			}
    		}

    		loop30:
    			;

    		} finally { DebugExitSubRule(30); }

    		DebugLocation(1199, 26);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1199:26: ( '\\r' )?
    		int alt31=2;
    		try { DebugEnterSubRule(31);
    		try { DebugEnterDecision(31, decisionCanBacktrack[31]);
    		int LA31_1 = input.LA(1);

    		if ((LA31_1=='\r'))
    		{
    			alt31 = 1;
    		}
    		} finally { DebugExitDecision(31); }
    		switch (alt31)
    		{
    		case 1:
    			DebugEnterAlt(1);
    			// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1199:26: '\\r'
    			{
    			DebugLocation(1199, 26);
    			Match('\r'); 

    			}
    			break;

    		}
    		} finally { DebugExitSubRule(31); }

    		DebugLocation(1199, 32);
    		Match('\n'); 

    		}

    	}
    	finally
    	{
    		TraceOut("LINE_COMMENT", 111);
    		LeaveRule("LINE_COMMENT", 111);
    		LeaveRule_LINE_COMMENT();
        }
    }
    // $ANTLR end "LINE_COMMENT"

    public override void mTokens()
    {
    	// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:8: ( T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | T__114 | HexLiteral | DecimalLiteral | OctalLiteral | FloatingPointLiteral | CharacterLiteral | StringLiteral | ENUM | ASSERT | Identifier | WS | Comments )
    	int alt32=100;
    	try { DebugEnterDecision(32, decisionCanBacktrack[32]);
    	try
    	{
    		alt32 = dfa32.Predict(input);
    	}
    	catch (NoViableAltException nvae)
    	{
    		DebugRecognitionException(nvae);
    		throw;
    	}
    	} finally { DebugExitDecision(32); }
    	switch (alt32)
    	{
    	case 1:
    		DebugEnterAlt(1);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:10: T__26
    		{
    		DebugLocation(1, 10);
    		mT__26(); 

    		}
    		break;
    	case 2:
    		DebugEnterAlt(2);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:16: T__27
    		{
    		DebugLocation(1, 16);
    		mT__27(); 

    		}
    		break;
    	case 3:
    		DebugEnterAlt(3);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:22: T__28
    		{
    		DebugLocation(1, 22);
    		mT__28(); 

    		}
    		break;
    	case 4:
    		DebugEnterAlt(4);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:28: T__29
    		{
    		DebugLocation(1, 28);
    		mT__29(); 

    		}
    		break;
    	case 5:
    		DebugEnterAlt(5);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:34: T__30
    		{
    		DebugLocation(1, 34);
    		mT__30(); 

    		}
    		break;
    	case 6:
    		DebugEnterAlt(6);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:40: T__31
    		{
    		DebugLocation(1, 40);
    		mT__31(); 

    		}
    		break;
    	case 7:
    		DebugEnterAlt(7);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:46: T__32
    		{
    		DebugLocation(1, 46);
    		mT__32(); 

    		}
    		break;
    	case 8:
    		DebugEnterAlt(8);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:52: T__33
    		{
    		DebugLocation(1, 52);
    		mT__33(); 

    		}
    		break;
    	case 9:
    		DebugEnterAlt(9);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:58: T__34
    		{
    		DebugLocation(1, 58);
    		mT__34(); 

    		}
    		break;
    	case 10:
    		DebugEnterAlt(10);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:64: T__35
    		{
    		DebugLocation(1, 64);
    		mT__35(); 

    		}
    		break;
    	case 11:
    		DebugEnterAlt(11);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:70: T__36
    		{
    		DebugLocation(1, 70);
    		mT__36(); 

    		}
    		break;
    	case 12:
    		DebugEnterAlt(12);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:76: T__37
    		{
    		DebugLocation(1, 76);
    		mT__37(); 

    		}
    		break;
    	case 13:
    		DebugEnterAlt(13);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:82: T__38
    		{
    		DebugLocation(1, 82);
    		mT__38(); 

    		}
    		break;
    	case 14:
    		DebugEnterAlt(14);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:88: T__39
    		{
    		DebugLocation(1, 88);
    		mT__39(); 

    		}
    		break;
    	case 15:
    		DebugEnterAlt(15);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:94: T__40
    		{
    		DebugLocation(1, 94);
    		mT__40(); 

    		}
    		break;
    	case 16:
    		DebugEnterAlt(16);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:100: T__41
    		{
    		DebugLocation(1, 100);
    		mT__41(); 

    		}
    		break;
    	case 17:
    		DebugEnterAlt(17);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:106: T__42
    		{
    		DebugLocation(1, 106);
    		mT__42(); 

    		}
    		break;
    	case 18:
    		DebugEnterAlt(18);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:112: T__43
    		{
    		DebugLocation(1, 112);
    		mT__43(); 

    		}
    		break;
    	case 19:
    		DebugEnterAlt(19);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:118: T__44
    		{
    		DebugLocation(1, 118);
    		mT__44(); 

    		}
    		break;
    	case 20:
    		DebugEnterAlt(20);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:124: T__45
    		{
    		DebugLocation(1, 124);
    		mT__45(); 

    		}
    		break;
    	case 21:
    		DebugEnterAlt(21);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:130: T__46
    		{
    		DebugLocation(1, 130);
    		mT__46(); 

    		}
    		break;
    	case 22:
    		DebugEnterAlt(22);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:136: T__47
    		{
    		DebugLocation(1, 136);
    		mT__47(); 

    		}
    		break;
    	case 23:
    		DebugEnterAlt(23);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:142: T__48
    		{
    		DebugLocation(1, 142);
    		mT__48(); 

    		}
    		break;
    	case 24:
    		DebugEnterAlt(24);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:148: T__49
    		{
    		DebugLocation(1, 148);
    		mT__49(); 

    		}
    		break;
    	case 25:
    		DebugEnterAlt(25);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:154: T__50
    		{
    		DebugLocation(1, 154);
    		mT__50(); 

    		}
    		break;
    	case 26:
    		DebugEnterAlt(26);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:160: T__51
    		{
    		DebugLocation(1, 160);
    		mT__51(); 

    		}
    		break;
    	case 27:
    		DebugEnterAlt(27);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:166: T__52
    		{
    		DebugLocation(1, 166);
    		mT__52(); 

    		}
    		break;
    	case 28:
    		DebugEnterAlt(28);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:172: T__53
    		{
    		DebugLocation(1, 172);
    		mT__53(); 

    		}
    		break;
    	case 29:
    		DebugEnterAlt(29);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:178: T__54
    		{
    		DebugLocation(1, 178);
    		mT__54(); 

    		}
    		break;
    	case 30:
    		DebugEnterAlt(30);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:184: T__55
    		{
    		DebugLocation(1, 184);
    		mT__55(); 

    		}
    		break;
    	case 31:
    		DebugEnterAlt(31);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:190: T__56
    		{
    		DebugLocation(1, 190);
    		mT__56(); 

    		}
    		break;
    	case 32:
    		DebugEnterAlt(32);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:196: T__57
    		{
    		DebugLocation(1, 196);
    		mT__57(); 

    		}
    		break;
    	case 33:
    		DebugEnterAlt(33);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:202: T__58
    		{
    		DebugLocation(1, 202);
    		mT__58(); 

    		}
    		break;
    	case 34:
    		DebugEnterAlt(34);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:208: T__59
    		{
    		DebugLocation(1, 208);
    		mT__59(); 

    		}
    		break;
    	case 35:
    		DebugEnterAlt(35);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:214: T__60
    		{
    		DebugLocation(1, 214);
    		mT__60(); 

    		}
    		break;
    	case 36:
    		DebugEnterAlt(36);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:220: T__61
    		{
    		DebugLocation(1, 220);
    		mT__61(); 

    		}
    		break;
    	case 37:
    		DebugEnterAlt(37);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:226: T__62
    		{
    		DebugLocation(1, 226);
    		mT__62(); 

    		}
    		break;
    	case 38:
    		DebugEnterAlt(38);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:232: T__63
    		{
    		DebugLocation(1, 232);
    		mT__63(); 

    		}
    		break;
    	case 39:
    		DebugEnterAlt(39);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:238: T__64
    		{
    		DebugLocation(1, 238);
    		mT__64(); 

    		}
    		break;
    	case 40:
    		DebugEnterAlt(40);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:244: T__65
    		{
    		DebugLocation(1, 244);
    		mT__65(); 

    		}
    		break;
    	case 41:
    		DebugEnterAlt(41);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:250: T__66
    		{
    		DebugLocation(1, 250);
    		mT__66(); 

    		}
    		break;
    	case 42:
    		DebugEnterAlt(42);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:256: T__67
    		{
    		DebugLocation(1, 256);
    		mT__67(); 

    		}
    		break;
    	case 43:
    		DebugEnterAlt(43);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:262: T__68
    		{
    		DebugLocation(1, 262);
    		mT__68(); 

    		}
    		break;
    	case 44:
    		DebugEnterAlt(44);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:268: T__69
    		{
    		DebugLocation(1, 268);
    		mT__69(); 

    		}
    		break;
    	case 45:
    		DebugEnterAlt(45);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:274: T__70
    		{
    		DebugLocation(1, 274);
    		mT__70(); 

    		}
    		break;
    	case 46:
    		DebugEnterAlt(46);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:280: T__71
    		{
    		DebugLocation(1, 280);
    		mT__71(); 

    		}
    		break;
    	case 47:
    		DebugEnterAlt(47);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:286: T__72
    		{
    		DebugLocation(1, 286);
    		mT__72(); 

    		}
    		break;
    	case 48:
    		DebugEnterAlt(48);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:292: T__73
    		{
    		DebugLocation(1, 292);
    		mT__73(); 

    		}
    		break;
    	case 49:
    		DebugEnterAlt(49);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:298: T__74
    		{
    		DebugLocation(1, 298);
    		mT__74(); 

    		}
    		break;
    	case 50:
    		DebugEnterAlt(50);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:304: T__75
    		{
    		DebugLocation(1, 304);
    		mT__75(); 

    		}
    		break;
    	case 51:
    		DebugEnterAlt(51);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:310: T__76
    		{
    		DebugLocation(1, 310);
    		mT__76(); 

    		}
    		break;
    	case 52:
    		DebugEnterAlt(52);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:316: T__77
    		{
    		DebugLocation(1, 316);
    		mT__77(); 

    		}
    		break;
    	case 53:
    		DebugEnterAlt(53);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:322: T__78
    		{
    		DebugLocation(1, 322);
    		mT__78(); 

    		}
    		break;
    	case 54:
    		DebugEnterAlt(54);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:328: T__79
    		{
    		DebugLocation(1, 328);
    		mT__79(); 

    		}
    		break;
    	case 55:
    		DebugEnterAlt(55);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:334: T__80
    		{
    		DebugLocation(1, 334);
    		mT__80(); 

    		}
    		break;
    	case 56:
    		DebugEnterAlt(56);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:340: T__81
    		{
    		DebugLocation(1, 340);
    		mT__81(); 

    		}
    		break;
    	case 57:
    		DebugEnterAlt(57);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:346: T__82
    		{
    		DebugLocation(1, 346);
    		mT__82(); 

    		}
    		break;
    	case 58:
    		DebugEnterAlt(58);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:352: T__83
    		{
    		DebugLocation(1, 352);
    		mT__83(); 

    		}
    		break;
    	case 59:
    		DebugEnterAlt(59);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:358: T__84
    		{
    		DebugLocation(1, 358);
    		mT__84(); 

    		}
    		break;
    	case 60:
    		DebugEnterAlt(60);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:364: T__85
    		{
    		DebugLocation(1, 364);
    		mT__85(); 

    		}
    		break;
    	case 61:
    		DebugEnterAlt(61);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:370: T__86
    		{
    		DebugLocation(1, 370);
    		mT__86(); 

    		}
    		break;
    	case 62:
    		DebugEnterAlt(62);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:376: T__87
    		{
    		DebugLocation(1, 376);
    		mT__87(); 

    		}
    		break;
    	case 63:
    		DebugEnterAlt(63);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:382: T__88
    		{
    		DebugLocation(1, 382);
    		mT__88(); 

    		}
    		break;
    	case 64:
    		DebugEnterAlt(64);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:388: T__89
    		{
    		DebugLocation(1, 388);
    		mT__89(); 

    		}
    		break;
    	case 65:
    		DebugEnterAlt(65);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:394: T__90
    		{
    		DebugLocation(1, 394);
    		mT__90(); 

    		}
    		break;
    	case 66:
    		DebugEnterAlt(66);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:400: T__91
    		{
    		DebugLocation(1, 400);
    		mT__91(); 

    		}
    		break;
    	case 67:
    		DebugEnterAlt(67);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:406: T__92
    		{
    		DebugLocation(1, 406);
    		mT__92(); 

    		}
    		break;
    	case 68:
    		DebugEnterAlt(68);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:412: T__93
    		{
    		DebugLocation(1, 412);
    		mT__93(); 

    		}
    		break;
    	case 69:
    		DebugEnterAlt(69);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:418: T__94
    		{
    		DebugLocation(1, 418);
    		mT__94(); 

    		}
    		break;
    	case 70:
    		DebugEnterAlt(70);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:424: T__95
    		{
    		DebugLocation(1, 424);
    		mT__95(); 

    		}
    		break;
    	case 71:
    		DebugEnterAlt(71);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:430: T__96
    		{
    		DebugLocation(1, 430);
    		mT__96(); 

    		}
    		break;
    	case 72:
    		DebugEnterAlt(72);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:436: T__97
    		{
    		DebugLocation(1, 436);
    		mT__97(); 

    		}
    		break;
    	case 73:
    		DebugEnterAlt(73);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:442: T__98
    		{
    		DebugLocation(1, 442);
    		mT__98(); 

    		}
    		break;
    	case 74:
    		DebugEnterAlt(74);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:448: T__99
    		{
    		DebugLocation(1, 448);
    		mT__99(); 

    		}
    		break;
    	case 75:
    		DebugEnterAlt(75);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:454: T__100
    		{
    		DebugLocation(1, 454);
    		mT__100(); 

    		}
    		break;
    	case 76:
    		DebugEnterAlt(76);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:461: T__101
    		{
    		DebugLocation(1, 461);
    		mT__101(); 

    		}
    		break;
    	case 77:
    		DebugEnterAlt(77);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:468: T__102
    		{
    		DebugLocation(1, 468);
    		mT__102(); 

    		}
    		break;
    	case 78:
    		DebugEnterAlt(78);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:475: T__103
    		{
    		DebugLocation(1, 475);
    		mT__103(); 

    		}
    		break;
    	case 79:
    		DebugEnterAlt(79);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:482: T__104
    		{
    		DebugLocation(1, 482);
    		mT__104(); 

    		}
    		break;
    	case 80:
    		DebugEnterAlt(80);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:489: T__105
    		{
    		DebugLocation(1, 489);
    		mT__105(); 

    		}
    		break;
    	case 81:
    		DebugEnterAlt(81);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:496: T__106
    		{
    		DebugLocation(1, 496);
    		mT__106(); 

    		}
    		break;
    	case 82:
    		DebugEnterAlt(82);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:503: T__107
    		{
    		DebugLocation(1, 503);
    		mT__107(); 

    		}
    		break;
    	case 83:
    		DebugEnterAlt(83);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:510: T__108
    		{
    		DebugLocation(1, 510);
    		mT__108(); 

    		}
    		break;
    	case 84:
    		DebugEnterAlt(84);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:517: T__109
    		{
    		DebugLocation(1, 517);
    		mT__109(); 

    		}
    		break;
    	case 85:
    		DebugEnterAlt(85);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:524: T__110
    		{
    		DebugLocation(1, 524);
    		mT__110(); 

    		}
    		break;
    	case 86:
    		DebugEnterAlt(86);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:531: T__111
    		{
    		DebugLocation(1, 531);
    		mT__111(); 

    		}
    		break;
    	case 87:
    		DebugEnterAlt(87);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:538: T__112
    		{
    		DebugLocation(1, 538);
    		mT__112(); 

    		}
    		break;
    	case 88:
    		DebugEnterAlt(88);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:545: T__113
    		{
    		DebugLocation(1, 545);
    		mT__113(); 

    		}
    		break;
    	case 89:
    		DebugEnterAlt(89);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:552: T__114
    		{
    		DebugLocation(1, 552);
    		mT__114(); 

    		}
    		break;
    	case 90:
    		DebugEnterAlt(90);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:559: HexLiteral
    		{
    		DebugLocation(1, 559);
    		mHexLiteral(); 

    		}
    		break;
    	case 91:
    		DebugEnterAlt(91);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:570: DecimalLiteral
    		{
    		DebugLocation(1, 570);
    		mDecimalLiteral(); 

    		}
    		break;
    	case 92:
    		DebugEnterAlt(92);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:585: OctalLiteral
    		{
    		DebugLocation(1, 585);
    		mOctalLiteral(); 

    		}
    		break;
    	case 93:
    		DebugEnterAlt(93);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:598: FloatingPointLiteral
    		{
    		DebugLocation(1, 598);
    		mFloatingPointLiteral(); 

    		}
    		break;
    	case 94:
    		DebugEnterAlt(94);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:619: CharacterLiteral
    		{
    		DebugLocation(1, 619);
    		mCharacterLiteral(); 

    		}
    		break;
    	case 95:
    		DebugEnterAlt(95);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:636: StringLiteral
    		{
    		DebugLocation(1, 636);
    		mStringLiteral(); 

    		}
    		break;
    	case 96:
    		DebugEnterAlt(96);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:650: ENUM
    		{
    		DebugLocation(1, 650);
    		mENUM(); 

    		}
    		break;
    	case 97:
    		DebugEnterAlt(97);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:655: ASSERT
    		{
    		DebugLocation(1, 655);
    		mASSERT(); 

    		}
    		break;
    	case 98:
    		DebugEnterAlt(98);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:662: Identifier
    		{
    		DebugLocation(1, 662);
    		mIdentifier(); 

    		}
    		break;
    	case 99:
    		DebugEnterAlt(99);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:673: WS
    		{
    		DebugLocation(1, 673);
    		mWS(); 

    		}
    		break;
    	case 100:
    		DebugEnterAlt(100);
    		// G:\\CECS547\\ANTLRReasoningCounter\\ANTLRReasoningCounter\\Java_MIT.g:1:676: Comments
    		{
    		DebugLocation(1, 676);
    		mComments(); 

    		}
    		break;

    	}

    }


	#region DFA
	DFA18 dfa18;
	DFA32 dfa32;

	protected override void InitDFAs()
	{
		base.InitDFAs();
		dfa18 = new DFA18(this);
		dfa32 = new DFA32(this);
	}

	private class DFA18 : DFA
	{
		private const string DFA18_eotS =
			"\x6\xFFFF";
		private const string DFA18_eofS =
			"\x6\xFFFF";
		private const string DFA18_minS =
			"\x2\x2E\x4\xFFFF";
		private const string DFA18_maxS =
			"\x1\x39\x1\x66\x4\xFFFF";
		private const string DFA18_acceptS =
			"\x2\xFFFF\x1\x2\x1\x1\x1\x3\x1\x4";
		private const string DFA18_specialS =
			"\x6\xFFFF}>";
		private static readonly string[] DFA18_transitionS =
			{
				"\x1\x2\x1\xFFFF\xA\x1",
				"\x1\x3\x1\xFFFF\xA\x1\xA\xFFFF\x1\x5\x1\x4\x1\x5\x1D\xFFFF\x1\x5\x1"+
				"\x4\x1\x5",
				"",
				"",
				"",
				""
			};

		private static readonly short[] DFA18_eot = DFA.UnpackEncodedString(DFA18_eotS);
		private static readonly short[] DFA18_eof = DFA.UnpackEncodedString(DFA18_eofS);
		private static readonly char[] DFA18_min = DFA.UnpackEncodedStringToUnsignedChars(DFA18_minS);
		private static readonly char[] DFA18_max = DFA.UnpackEncodedStringToUnsignedChars(DFA18_maxS);
		private static readonly short[] DFA18_accept = DFA.UnpackEncodedString(DFA18_acceptS);
		private static readonly short[] DFA18_special = DFA.UnpackEncodedString(DFA18_specialS);
		private static readonly short[][] DFA18_transition;

		static DFA18()
		{
			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]);
			}
		}

		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 override string Description { get { return "1090:1: FloatingPointLiteral : ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | ( '0' .. '9' )+ FloatTypeSuffix );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

	private class DFA32 : DFA
	{
		private const string DFA32_eotS =
			"\x1\xFFFF\x1\x30\x1\x32\x1\x35\x2\xFFFF\x1\x37\x1\x3A\x1\xFFFF\x1\x3D"+
			"\x1\x3F\x1\x43\x3\xFFFF\x1\x45\x5\xFFFF\x1\x47\xF\x2D\x1\xFFFF\x1\x70"+
			"\x2\xFFFF\x2\x72\x1D\xFFFF\xA\x2D\x1\x81\x7\x2D\x1\x89\x13\x2D\x5\xFFFF"+
			"\x1\xA4\x1\x72\xC\x2D\x1\xFFFF\x6\x2D\x1\xB7\x1\xFFFF\x2\x2D\x1\xBC\x2"+
			"\x2D\x1\xBF\x10\x2D\x1\xD0\x3\x2D\x1\xFFFF\x4\x2D\x1\xD8\x1\xD9\x1\x2D"+
			"\x1\xDB\x4\x2D\x1\xE0\x1\x2D\x1\xE2\x3\x2D\x1\xFFFF\x4\x2D\x1\xFFFF\x1"+
			"\xEA\x1\x2D\x1\xFFFF\x1\xEC\xB\x2D\x1\xF8\x2\x2D\x1\xFB\x1\xFFFF\x1\xFC"+
			"\x5\x2D\x1\x102\x2\xFFFF\x1\x103\x1\xFFFF\x1\x104\x3\x2D\x1\xFFFF\x1"+
			"\x2D\x1\xFFFF\x1\x109\x1\x10B\x1\x10C\x4\x2D\x1\xFFFF\x1\x2D\x1\xFFFF"+
			"\x5\x2D\x1\x117\x2\x2D\x1\x11A\x2\x2D\x1\xFFFF\x1\x11E\x1\x2D\x2\xFFFF"+
			"\x1\x2D\x1\x121\x1\x2D\x1\x123\x1\x2D\x3\xFFFF\x2\x2D\x1\x127\x1\x2D"+
			"\x1\xFFFF\x1\x2D\x2\xFFFF\x1\x2D\x1\x12B\x2\x2D\x1\x12E\x3\x2D\x1\x132"+
			"\x1\x133\x1\xFFFF\x1\x134\x1\x2D\x1\xFFFF\x1\x136\x1\x2D\x1\x138\x1\xFFFF"+
			"\x2\x2D\x1\xFFFF\x1\x2D\x1\xFFFF\x1\x13C\x1\x2D\x1\x13E\x1\xFFFF\x1\x13F"+
			"\x1\x140\x1\x2D\x1\xFFFF\x2\x2D\x1\xFFFF\x1\x144\x1\x145\x1\x2D\x3\xFFFF"+
			"\x1\x2D\x1\xFFFF\x1\x2D\x1\xFFFF\x2\x2D\x1\x14B\x1\xFFFF\x1\x14C\x3\xFFFF"+
			"\x3\x2D\x2\xFFFF\x1\x2D\x1\x151\x2\x2D\x1\x154\x2\xFFFF\x2\x2D\x1\x157"+
			"\x1\x158\x1\xFFFF\x1\x2D\x1\x15A\x1\xFFFF\x1\x15B\x1\x15C\x2\xFFFF\x1"+
			"\x2D\x3\xFFFF\x1\x2D\x1\x15F\x1\xFFFF";
		private const string DFA32_eofS =
			"\x160\xFFFF";
		private const string DFA32_minS =
			"\x1\x9\x2\x3D\x1\x26\x2\xFFFF\x1\x3D\x1\x2B\x1\xFFFF\x1\x2D\x1\x2E\x1"+
			"\x2A\x3\xFFFF\x1\x3D\x5\xFFFF\x1\x3D\x1\x62\x1\x6F\x1\x61\x1\x65\x1\x6C"+
			"\x1\x61\x1\x66\x1\x6F\x2\x61\x1\x65\x2\x68\x1\x6F\x1\x68\x1\xFFFF\x1"+
			"\x3D\x2\xFFFF\x2\x2E\x1D\xFFFF\x2\x73\x1\x6F\x1\x65\x1\x74\x1\x73\x2"+
			"\x61\x1\x6E\x1\x66\x1\x24\x1\x73\x1\x74\x1\x75\x1\x6C\x1\x6E\x1\x6F\x1"+
			"\x72\x1\x24\x1\x70\x1\x73\x1\x6E\x1\x74\x1\x77\x1\x6C\x1\x63\x1\x69\x1"+
			"\x62\x1\x74\x1\x6F\x1\x61\x1\x70\x1\x69\x1\x6E\x1\x69\x1\x61\x2\x69\x5"+
			"\xFFFF\x2\x2E\x1\x74\x1\x65\x1\x6C\x1\x61\x2\x65\x1\x63\x1\x72\x1\x73"+
			"\x1\x74\x1\x61\x1\x62\x1\xFFFF\x2\x65\x1\x6D\x1\x73\x2\x61\x1\x24\x1"+
			"\xFFFF\x1\x6C\x1\x74\x1\x24\x1\x67\x1\x69\x1\x24\x1\x6C\x1\x6B\x1\x76"+
			"\x1\x74\x1\x6C\x1\x75\x1\x72\x1\x74\x1\x69\x1\x65\x1\x74\x1\x63\x1\x73"+
			"\x1\x6F\x1\x6E\x1\x65\x1\x24\x1\x64\x1\x61\x1\x6C\x1\xFFFF\x2\x72\x1"+
			"\x65\x1\x6B\x2\x24\x1\x68\x1\x24\x1\x73\x1\x69\x1\x75\x1\x6C\x1\x24\x1"+
			"\x6E\x1\x24\x1\x65\x1\x6C\x1\x74\x1\xFFFF\x1\x65\x1\x72\x1\x61\x1\x72"+
			"\x1\xFFFF\x1\x24\x1\x76\x1\xFFFF\x1\x24\x2\x61\x1\x65\x1\x69\x1\x72\x1"+
			"\x74\x1\x69\x1\x63\x1\x72\x1\x63\x1\x68\x1\x24\x1\x77\x1\x73\x1\x24\x1"+
			"\xFFFF\x1\x24\x1\x74\x1\x65\x1\x61\x1\x74\x1\x61\x1\x24\x2\xFFFF\x1\x24"+
			"\x1\xFFFF\x1\x24\x1\x6E\x1\x6C\x1\x65\x1\xFFFF\x1\x64\x1\xFFFF\x3\x24"+
			"\x1\x6D\x1\x74\x1\x6E\x1\x66\x1\xFFFF\x1\x65\x1\xFFFF\x1\x67\x1\x74\x2"+
			"\x63\x1\x6E\x1\x24\x1\x63\x1\x74\x1\x24\x1\x68\x1\x72\x1\xFFFF\x1\x24"+
			"\x1\x69\x2\xFFFF\x1\x69\x1\x24\x1\x63\x1\x24\x1\x6E\x3\xFFFF\x1\x75\x1"+
			"\x74\x1\x24\x1\x73\x1\xFFFF\x1\x79\x2\xFFFF\x1\x65\x1\x24\x1\x63\x1\x61"+
			"\x1\x24\x2\x65\x1\x74\x2\x24\x1\xFFFF\x1\x24\x1\x66\x1\xFFFF\x1\x24\x1"+
			"\x6F\x1\x24\x1\xFFFF\x1\x65\x1\x6C\x1\xFFFF\x1\x74\x1\xFFFF\x1\x24\x1"+
			"\x65\x1\x24\x1\xFFFF\x2\x24\x1\x6E\x1\xFFFF\x1\x65\x1\x63\x1\xFFFF\x2"+
			"\x24\x1\x65\x3\xFFFF\x1\x70\x1\xFFFF\x1\x6E\x1\xFFFF\x1\x6E\x1\x65\x1"+
			"\x24\x1\xFFFF\x1\x24\x3\xFFFF\x1\x74\x1\x6F\x1\x65\x2\xFFFF\x1\x64\x1"+
			"\x24\x1\x69\x1\x74\x1\x24\x2\xFFFF\x1\x73\x1\x66\x2\x24\x1\xFFFF\x1\x7A"+
			"\x1\x24\x1\xFFFF\x2\x24\x2\xFFFF\x1\x65\x3\xFFFF\x1\x64\x1\x24\x1\xFFFF";
		private const string DFA32_maxS =
			"\x1\xFAFF\x3\x3D\x2\xFFFF\x2\x3D\x1\xFFFF\x1\x3D\x1\x39\x1\x3D\x3\xFFFF"+
			"\x1\x3D\x5\xFFFF\x1\x3D\x1\x73\x1\x79\x2\x6F\x1\x78\x1\x6F\x1\x6E\x1"+
			"\x6F\x2\x75\x1\x65\x1\x79\x1\x72\x1\x6F\x1\x68\x1\xFFFF\x1\x7C\x2\xFFFF"+
			"\x1\x78\x1\x66\x1D\xFFFF\x2\x73\x1\x6F\x1\x65\x2\x74\x2\x61\x1\x6E\x1"+
			"\x66\x1\xFAFF\x1\x73\x1\x74\x1\x75\x1\x6C\x1\x6E\x1\x6F\x1\x72\x1\xFAFF"+
			"\x1\x70\x1\x74\x1\x6E\x1\x74\x1\x77\x1\x6C\x1\x63\x1\x6F\x1\x62\x1\x74"+
			"\x1\x6F\x1\x72\x1\x70\x1\x69\x1\x6E\x1\x72\x1\x79\x1\x6C\x1\x69\x5\xFFFF"+
			"\x2\x66\x1\x74\x1\x65\x1\x6C\x1\x61\x2\x65\x1\x63\x1\x72\x1\x73\x1\x74"+
			"\x1\x61\x1\x62\x1\xFFFF\x2\x65\x1\x6D\x1\x73\x2\x61\x1\xFAFF\x1\xFFFF"+
			"\x1\x6F\x1\x74\x1\xFAFF\x1\x67\x1\x69\x1\xFAFF\x1\x6C\x1\x6B\x1\x76\x1"+
			"\x74\x1\x6C\x1\x75\x1\x72\x1\x74\x1\x69\x1\x65\x1\x74\x1\x63\x1\x73\x1"+
			"\x6F\x1\x6E\x1\x65\x1\xFAFF\x1\x64\x1\x61\x1\x6C\x1\xFFFF\x2\x72\x1\x65"+
			"\x1\x6B\x2\xFAFF\x1\x68\x1\xFAFF\x1\x73\x1\x69\x1\x75\x1\x6C\x1\xFAFF"+
			"\x1\x6E\x1\xFAFF\x1\x65\x1\x6C\x1\x74\x1\xFFFF\x1\x65\x1\x72\x1\x61\x1"+
			"\x72\x1\xFFFF\x1\xFAFF\x1\x76\x1\xFFFF\x1\xFAFF\x2\x61\x1\x65\x1\x69"+
			"\x1\x72\x1\x74\x1\x69\x1\x63\x1\x72\x1\x63\x1\x68\x1\xFAFF\x1\x77\x1"+
			"\x73\x1\xFAFF\x1\xFFFF\x1\xFAFF\x1\x74\x1\x65\x1\x61\x1\x74\x1\x61\x1"+
			"\xFAFF\x2\xFFFF\x1\xFAFF\x1\xFFFF\x1\xFAFF\x1\x6E\x1\x6C\x1\x65\x1\xFFFF"+
			"\x1\x64\x1\xFFFF\x3\xFAFF\x1\x6D\x1\x74\x1\x6E\x1\x66\x1\xFFFF\x1\x65"+
			"\x1\xFFFF\x1\x67\x1\x74\x2\x63\x1\x6E\x1\xFAFF\x1\x63\x1\x74\x1\xFAFF"+
			"\x1\x68\x1\x72\x1\xFFFF\x1\xFAFF\x1\x69\x2\xFFFF\x1\x69\x1\xFAFF\x1\x63"+
			"\x1\xFAFF\x1\x6E\x3\xFFFF\x1\x75\x1\x74\x1\xFAFF\x1\x73\x1\xFFFF\x1\x79"+
			"\x2\xFFFF\x1\x65\x1\xFAFF\x1\x63\x1\x61\x1\xFAFF\x2\x65\x1\x74\x2\xFAFF"+
			"\x1\xFFFF\x1\xFAFF\x1\x66\x1\xFFFF\x1\xFAFF\x1\x6F\x1\xFAFF\x1\xFFFF"+
			"\x1\x65\x1\x6C\x1\xFFFF\x1\x74\x1\xFFFF\x1\xFAFF\x1\x65\x1\xFAFF\x1\xFFFF"+
			"\x2\xFAFF\x1\x6E\x1\xFFFF\x1\x65\x1\x63\x1\xFFFF\x2\xFAFF\x1\x65\x3\xFFFF"+
			"\x1\x70\x1\xFFFF\x1\x6E\x1\xFFFF\x1\x6E\x1\x65\x1\xFAFF\x1\xFFFF\x1\xFAFF"+
			"\x3\xFFFF\x1\x74\x1\x6F\x1\x65\x2\xFFFF\x1\x64\x1\xFAFF\x1\x69\x1\x74"+
			"\x1\xFAFF\x2\xFFFF\x1\x73\x1\x66\x2\xFAFF\x1\xFFFF\x1\x7A\x1\xFAFF\x1"+
			"\xFFFF\x2\xFAFF\x2\xFFFF\x1\x65\x3\xFFFF\x1\x64\x1\xFAFF\x1\xFFFF";
		private const string DFA32_acceptS =
			"\x4\xFFFF\x1\x8\x1\x9\x2\xFFFF\x1\xF\x3\xFFFF\x1\x17\x1\x18\x1\x19\x1"+
			"\xFFFF\x1\x1C\x1\x1D\x1\x1E\x1\x1F\x1\x20\x10\xFFFF\x1\x54\x1\xFFFF\x1"+
			"\x58\x1\x59\x2\xFFFF\x1\x5E\x1\x5F\x1\x62\x1\x63\x1\x2\x1\x1\x1\x4\x1"+
			"\x3\x1\x5\x1\x7\x1\x6\x1\xB\x1\xA\x1\xD\x1\xE\x1\xC\x1\x11\x1\x12\x1"+
			"\x10\x1\x14\x1\x13\x1\x5D\x1\x16\x1\x64\x1\x15\x1\x1B\x1\x1A\x1\x22\x1"+
			"\x21\x26\xFFFF\x1\x56\x1\x57\x1\x55\x1\x5A\x1\x5B\xE\xFFFF\x1\x2D\x7"+
			"\xFFFF\x1\x36\x1A\xFFFF\x1\x5C\x12\xFFFF\x1\x35\x4\xFFFF\x1\x3A\x2\xFFFF"+
			"\x1\x3E\x10\xFFFF\x1\x50\x7\xFFFF\x1\x26\x1\x27\x1\xFFFF\x1\x29\x4\xFFFF"+
			"\x1\x2F\x1\xFFFF\x1\x60\x7\xFFFF\x1\x3C\x1\xFFFF\x1\x3F\xB\xFFFF\x1\x4B"+
			"\x2\xFFFF\x1\x4F\x1\x51\x5\xFFFF\x1\x25\x1\x28\x1\x2A\x4\xFFFF\x1\x31"+
			"\x1\xFFFF\x1\x32\x1\x34\xA\xFFFF\x1\x45\x2\xFFFF\x1\x48\x3\xFFFF\x1\x4C"+
			"\x2\xFFFF\x1\x53\x1\xFFFF\x1\x61\x3\xFFFF\x1\x2E\x3\xFFFF\x1\x38\x2\xFFFF"+
			"\x1\x3D\x3\xFFFF\x1\x43\x1\x44\x1\x46\x1\xFFFF\x1\x49\x1\xFFFF\x1\x4D"+
			"\x3\xFFFF\x1\x24\x1\xFFFF\x1\x2C\x1\x30\x1\x33\x3\xFFFF\x1\x40\x1\x41"+
			"\x5\xFFFF\x1\x23\x1\x2B\x4\xFFFF\x1\x47\x2\xFFFF\x1\x52\x2\xFFFF\x1\x3B"+
			"\x1\x42\x1\xFFFF\x1\x4E\x1\x37\x1\x39\x2\xFFFF\x1\x4A";
		private const string DFA32_specialS =
			"\x160\xFFFF}>";
		private static readonly string[] DFA32_transitionS =
			{
				"\x2\x2E\x1\xFFFF\x2\x2E\x12\xFFFF\x1\x2E\x1\x1\x1\x2C\x1\xFFFF\x1\x2D"+
				"\x1\x2\x1\x3\x1\x2B\x1\x4\x1\x5\x1\x6\x1\x7\x1\x8\x1\x9\x1\xA\x1\xB"+
				"\x1\x29\x9\x2A\x1\xC\x1\xD\x1\xE\x1\xF\x1\x10\x1\x11\x1\x12\x1A\x2D"+
				"\x1\x13\x1\xFFFF\x1\x14\x1\x15\x1\x2D\x1\xFFFF\x1\x16\x1\x17\x1\x18"+
				"\x1\x19\x1\x1A\x1\x1B\x2\x2D\x1\x1C\x2\x2D\x1\x1D\x1\x2D\x1\x1E\x1\x2D"+
				"\x1\x1F\x1\x2D\x1\x20\x1\x21\x1\x22\x1\x2D\x1\x23\x1\x24\x3\x2D\x1\x25"+
				"\x1\x26\x1\x27\x1\x28\x41\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08"+
				"\x2D\x1040\xFFFF\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2"+
				"\xFFFF\x5200\x2D\x5900\xFFFF\x200\x2D",
				"\x1\x2F",
				"\x1\x31",
				"\x1\x33\x16\xFFFF\x1\x34",
				"",
				"",
				"\x1\x36",
				"\x1\x38\x11\xFFFF\x1\x39",
				"",
				"\x1\x3B\xF\xFFFF\x1\x3C",
				"\x1\x3E\x1\xFFFF\xA\x40",
				"\x1\x42\x4\xFFFF\x1\x42\xD\xFFFF\x1\x41",
				"",
				"",
				"",
				"\x1\x44",
				"",
				"",
				"",
				"",
				"",
				"\x1\x46",
				"\x1\x48\x10\xFFFF\x1\x49",
				"\x1\x4A\x2\xFFFF\x1\x4B\x6\xFFFF\x1\x4C",
				"\x1\x4D\x6\xFFFF\x1\x4E\x3\xFFFF\x1\x4F\x2\xFFFF\x1\x50",
				"\x1\x51\x9\xFFFF\x1\x52",
				"\x1\x53\x1\xFFFF\x1\x55\x9\xFFFF\x1\x54",
				"\x1\x56\x7\xFFFF\x1\x57\x2\xFFFF\x1\x58\x2\xFFFF\x1\x59",
				"\x1\x5A\x6\xFFFF\x1\x5B\x1\x5C",
				"\x1\x5D",
				"\x1\x5E\x3\xFFFF\x1\x5F\xF\xFFFF\x1\x60",
				"\x1\x61\x10\xFFFF\x1\x62\x2\xFFFF\x1\x63",
				"\x1\x64",
				"\x1\x65\xB\xFFFF\x1\x66\x1\x67\x1\xFFFF\x1\x68\x1\xFFFF\x1\x69",
				"\x1\x6A\x9\xFFFF\x1\x6B",
				"\x1\x6C",
				"\x1\x6D",
				"",
				"\x1\x6E\x3E\xFFFF\x1\x6F",
				"",
				"",
				"\x1\x40\x1\xFFFF\x8\x73\x2\x40\xA\xFFFF\x3\x40\x11\xFFFF\x1\x71\xB"+
				"\xFFFF\x3\x40\x11\xFFFF\x1\x71",
				"\x1\x40\x1\xFFFF\xA\x74\xA\xFFFF\x3\x40\x1D\xFFFF\x3\x40",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"\x1\x75",
				"\x1\x76",
				"\x1\x77",
				"\x1\x78",
				"\x1\x79",
				"\x1\x7A\x1\x7B",
				"\x1\x7C",
				"\x1\x7D",
				"\x1\x7E",
				"\x1\x7F",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x14"+
				"\x2D\x1\x80\x5\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08"+
				"\x2D\x1040\xFFFF\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2"+
				"\xFFFF\x5200\x2D\x5900\xFFFF\x200\x2D",
				"\x1\x82",
				"\x1\x83",
				"\x1\x84",
				"\x1\x85",
				"\x1\x86",
				"\x1\x87",
				"\x1\x88",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x8A",
				"\x1\x8B\x1\x8C",
				"\x1\x8D",
				"\x1\x8E",
				"\x1\x8F",
				"\x1\x90",
				"\x1\x91",
				"\x1\x92\x5\xFFFF\x1\x93",
				"\x1\x94",
				"\x1\x95",
				"\x1\x96",
				"\x1\x97\x10\xFFFF\x1\x98",
				"\x1\x99",
				"\x1\x9A",
				"\x1\x9B",
				"\x1\x9C\x8\xFFFF\x1\x9D",
				"\x1\x9E\x13\xFFFF\x1\x9F\x3\xFFFF\x1\xA0",
				"\x1\xA1\x2\xFFFF\x1\xA2",
				"\x1\xA3",
				"",
				"",
				"",
				"",
				"",
				"\x1\x40\x1\xFFFF\x8\x73\x2\x40\xA\xFFFF\x3\x40\x1D\xFFFF\x3\x40",
				"\x1\x40\x1\xFFFF\xA\x74\xA\xFFFF\x3\x40\x1D\xFFFF\x3\x40",
				"\x1\xA5",
				"\x1\xA6",
				"\x1\xA7",
				"\x1\xA8",
				"\x1\xA9",
				"\x1\xAA",
				"\x1\xAB",
				"\x1\xAC",
				"\x1\xAD",
				"\x1\xAE",
				"\x1\xAF",
				"\x1\xB0",
				"",
				"\x1\xB1",
				"\x1\xB2",
				"\x1\xB3",
				"\x1\xB4",
				"\x1\xB5",
				"\x1\xB6",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\xB8\x2\xFFFF\x1\xB9",
				"\x1\xBA",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x4"+
				"\x2D\x1\xBB\x15\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08"+
				"\x2D\x1040\xFFFF\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2"+
				"\xFFFF\x5200\x2D\x5900\xFFFF\x200\x2D",
				"\x1\xBD",
				"\x1\xBE",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xC0",
				"\x1\xC1",
				"\x1\xC2",
				"\x1\xC3",
				"\x1\xC4",
				"\x1\xC5",
				"\x1\xC6",
				"\x1\xC7",
				"\x1\xC8",
				"\x1\xC9",
				"\x1\xCA",
				"\x1\xCB",
				"\x1\xCC",
				"\x1\xCD",
				"\x1\xCE",
				"\x1\xCF",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xD1",
				"\x1\xD2",
				"\x1\xD3",
				"",
				"\x1\xD4",
				"\x1\xD5",
				"\x1\xD6",
				"\x1\xD7",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xDA",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xDC",
				"\x1\xDD",
				"\x1\xDE",
				"\x1\xDF",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xE1",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xE3",
				"\x1\xE4",
				"\x1\xE5",
				"",
				"\x1\xE6",
				"\x1\xE7",
				"\x1\xE8",
				"\x1\xE9",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xEB",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xED",
				"\x1\xEE",
				"\x1\xEF",
				"\x1\xF0",
				"\x1\xF1",
				"\x1\xF2",
				"\x1\xF3",
				"\x1\xF4",
				"\x1\xF5",
				"\x1\xF6",
				"\x1\xF7",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xF9",
				"\x1\xFA",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\xFD",
				"\x1\xFE",
				"\x1\xFF",
				"\x1\x100",
				"\x1\x101",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x105",
				"\x1\x106",
				"\x1\x107",
				"",
				"\x1\x108",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\xB"+
				"\x2D\x1\x10A\xE\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08"+
				"\x2D\x1040\xFFFF\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2"+
				"\xFFFF\x5200\x2D\x5900\xFFFF\x200\x2D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x10D",
				"\x1\x10E",
				"\x1\x10F",
				"\x1\x110",
				"",
				"\x1\x111",
				"",
				"\x1\x112",
				"\x1\x113",
				"\x1\x114",
				"\x1\x115",
				"\x1\x116",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x118",
				"\x1\x119",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x11B",
				"\x1\x11C",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x12"+
				"\x2D\x1\x11D\x7\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08"+
				"\x2D\x1040\xFFFF\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2"+
				"\xFFFF\x5200\x2D\x5900\xFFFF\x200\x2D",
				"\x1\x11F",
				"",
				"",
				"\x1\x120",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x122",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x124",
				"",
				"",
				"",
				"\x1\x125",
				"\x1\x126",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x128",
				"",
				"\x1\x129",
				"",
				"",
				"\x1\x12A",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x12C",
				"\x1\x12D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x12F",
				"\x1\x130",
				"\x1\x131",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x135",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x137",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\x139",
				"\x1\x13A",
				"",
				"\x1\x13B",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x13D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x141",
				"",
				"\x1\x142",
				"\x1\x143",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x146",
				"",
				"",
				"",
				"\x1\x147",
				"",
				"\x1\x148",
				"",
				"\x1\x149",
				"\x1\x14A",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"",
				"",
				"\x1\x14D",
				"\x1\x14E",
				"\x1\x14F",
				"",
				"",
				"\x1\x150",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x152",
				"\x1\x153",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"",
				"\x1\x155",
				"\x1\x156",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\x159",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				"",
				"",
				"\x1\x15D",
				"",
				"",
				"",
				"\x1\x15E",
				"\x1\x2D\xB\xFFFF\xA\x2D\x7\xFFFF\x1A\x2D\x4\xFFFF\x1\x2D\x1\xFFFF\x1A"+
				"\x2D\x45\xFFFF\x17\x2D\x1\xFFFF\x1F\x2D\x1\xFFFF\x1F08\x2D\x1040\xFFFF"+
				"\x150\x2D\x170\xFFFF\x80\x2D\x80\xFFFF\x92E\x2D\x10D2\xFFFF\x5200\x2D"+
				"\x5900\xFFFF\x200\x2D",
				""
			};

		private static readonly short[] DFA32_eot = DFA.UnpackEncodedString(DFA32_eotS);
		private static readonly short[] DFA32_eof = DFA.UnpackEncodedString(DFA32_eofS);
		private static readonly char[] DFA32_min = DFA.UnpackEncodedStringToUnsignedChars(DFA32_minS);
		private static readonly char[] DFA32_max = DFA.UnpackEncodedStringToUnsignedChars(DFA32_maxS);
		private static readonly short[] DFA32_accept = DFA.UnpackEncodedString(DFA32_acceptS);
		private static readonly short[] DFA32_special = DFA.UnpackEncodedString(DFA32_specialS);
		private static readonly short[][] DFA32_transition;

		static DFA32()
		{
			int numStates = DFA32_transitionS.Length;
			DFA32_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA32_transition[i] = DFA.UnpackEncodedString(DFA32_transitionS[i]);
			}
		}

		public DFA32( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 32;
			this.eot = DFA32_eot;
			this.eof = DFA32_eof;
			this.min = DFA32_min;
			this.max = DFA32_max;
			this.accept = DFA32_accept;
			this.special = DFA32_special;
			this.transition = DFA32_transition;
		}

		public override string Description { get { return "1:1: Tokens : ( T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | T__114 | HexLiteral | DecimalLiteral | OctalLiteral | FloatingPointLiteral | CharacterLiteral | StringLiteral | ENUM | ASSERT | Identifier | WS | Comments );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

 
	#endregion

}