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

// Generated from /Users/melodidey/Source/csharp/Q1/Compiler/CGrammar.g4 by ANTLR 4.13.2

// Unreachable code detected
#pragma warning disable 0162
// The variable '...' is assigned but its value is never used
#pragma warning disable 0219
// Missing XML comment for publicly visible type or member '...'
#pragma warning disable 1591
// Ambiguous reference in cref attribute
#pragma warning disable 419

using System;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Collections.Generic;
using Antlr4.Runtime;
using Antlr4.Runtime.Atn;
using Antlr4.Runtime.Misc;
using Antlr4.Runtime.Tree;
using DFA = Antlr4.Runtime.Dfa.DFA;

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.13.2")]
[System.CLSCompliant(false)]
public partial class CGrammarParser : Parser {
	protected static DFA[] decisionToDFA;
	protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
	public const int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
		T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 
		T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, 
		T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, 
		T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, 
		T__52=53, T__53=54, HEX=55, ID=56, INT=57, WS=58, COMMENT=59, DIRECTIVE=60, 
		LETTER=61, STRING=62;
	public const int
		RULE_program = 0, RULE_function = 1, RULE_block = 2, RULE_block_item = 3, 
		RULE_statement = 4, RULE_declaration = 5, RULE_expression = 6, RULE_constant = 7, 
		RULE_type = 8, RULE_target = 9;
	public static readonly string[] ruleNames = {
		"program", "function", "block", "block_item", "statement", "declaration", 
		"expression", "constant", "type", "target"
	};

	private static readonly string[] _LiteralNames = {
		null, "'('", "','", "')'", "';'", "'{'", "'}'", "'return'", "'if'", "'else'", 
		"'for'", "'while'", "'do'", "'break'", "'continue'", "'='", "'new'", "'['", 
		"']'", "'*'", "'&'", "'!'", "'~'", "'++'", "'--'", "'/'", "'%'", "'+'", 
		"'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'|'", "'^'", "'<<'", 
		"'>>'", "'&&'", "'||'", "'*='", "'/='", "'%='", "'+='", "'-='", "'&='", 
		"'|='", "'^='", "'<<='", "'>>='", "'?'", "':'", "'int'", "'char'"
	};
	private static readonly string[] _SymbolicNames = {
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, "HEX", "ID", "INT", "WS", "COMMENT", 
		"DIRECTIVE", "LETTER", "STRING"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

	[NotNull]
	public override IVocabulary Vocabulary
	{
		get
		{
			return DefaultVocabulary;
		}
	}

	public override string GrammarFileName { get { return "CGrammar.g4"; } }

	public override string[] RuleNames { get { return ruleNames; } }

	public override int[] SerializedAtn { get { return _serializedATN; } }

	static CGrammarParser() {
		decisionToDFA = new DFA[_ATN.NumberOfDecisions];
		for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
			decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
		}
	}

		public CGrammarParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }

		public CGrammarParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
		: base(input, output, errorOutput)
	{
		Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
	}

	public partial class ProgramContext : Q1.Compiler.Context {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(CGrammarParser.Eof, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public FunctionContext[] function() {
			return GetRuleContexts<FunctionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FunctionContext function(int i) {
			return GetRuleContext<FunctionContext>(i);
		}
		public ProgramContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_program; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitProgram(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ProgramContext program() {
		ProgramContext _localctx = new ProgramContext(Context, State);
		EnterRule(_localctx, 0, RULE_program);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 21;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				{
				State = 20;
				function();
				}
				}
				State = 23;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( _la==T__52 || _la==T__53 );
			State = 25;
			Match(Eof);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FunctionContext : Q1.Compiler.Context {
		public FunctionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_function; } }
	 
		public FunctionContext() { }
		public virtual void CopyFrom(FunctionContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class FunctionPrototypeContext : FunctionContext {
		public TypeContext rtype;
		public IToken name;
		public TypeContext _type;
		public IList<TypeContext> _types = new List<TypeContext>();
		public IToken _ID;
		public IList<IToken> _params = new List<IToken>();
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext[] type() {
			return GetRuleContexts<TypeContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type(int i) {
			return GetRuleContext<TypeContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] ID() { return GetTokens(CGrammarParser.ID); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID(int i) {
			return GetToken(CGrammarParser.ID, i);
		}
		public FunctionPrototypeContext(FunctionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFunctionPrototype(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class FunctionDefinitionContext : FunctionContext {
		public TypeContext rtype;
		public IToken name;
		public TypeContext _type;
		public IList<TypeContext> _types = new List<TypeContext>();
		public IToken _ID;
		public IList<IToken> _params = new List<IToken>();
		[System.Diagnostics.DebuggerNonUserCode] public BlockContext block() {
			return GetRuleContext<BlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext[] type() {
			return GetRuleContexts<TypeContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type(int i) {
			return GetRuleContext<TypeContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] ID() { return GetTokens(CGrammarParser.ID); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID(int i) {
			return GetToken(CGrammarParser.ID, i);
		}
		public FunctionDefinitionContext(FunctionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFunctionDefinition(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FunctionContext function() {
		FunctionContext _localctx = new FunctionContext(Context, State);
		EnterRule(_localctx, 2, RULE_function);
		int _la;
		try {
			State = 65;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) {
			case 1:
				_localctx = new FunctionPrototypeContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 27;
				((FunctionPrototypeContext)_localctx).rtype = type(0);
				State = 28;
				((FunctionPrototypeContext)_localctx).name = Match(ID);
				State = 29;
				Match(T__0);
				State = 41;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==T__52 || _la==T__53) {
					{
					State = 30;
					((FunctionPrototypeContext)_localctx)._type = type(0);
					((FunctionPrototypeContext)_localctx)._types.Add(((FunctionPrototypeContext)_localctx)._type);
					State = 31;
					((FunctionPrototypeContext)_localctx)._ID = Match(ID);
					((FunctionPrototypeContext)_localctx)._params.Add(((FunctionPrototypeContext)_localctx)._ID);
					State = 38;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					while (_la==T__1) {
						{
						{
						State = 32;
						Match(T__1);
						State = 33;
						((FunctionPrototypeContext)_localctx)._type = type(0);
						((FunctionPrototypeContext)_localctx)._types.Add(((FunctionPrototypeContext)_localctx)._type);
						State = 34;
						((FunctionPrototypeContext)_localctx)._ID = Match(ID);
						((FunctionPrototypeContext)_localctx)._params.Add(((FunctionPrototypeContext)_localctx)._ID);
						}
						}
						State = 40;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
					}
					}
				}

				State = 43;
				Match(T__2);
				State = 44;
				Match(T__3);
				}
				break;
			case 2:
				_localctx = new FunctionDefinitionContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 46;
				((FunctionDefinitionContext)_localctx).rtype = type(0);
				State = 47;
				((FunctionDefinitionContext)_localctx).name = Match(ID);
				State = 48;
				Match(T__0);
				State = 60;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==T__52 || _la==T__53) {
					{
					State = 49;
					((FunctionDefinitionContext)_localctx)._type = type(0);
					((FunctionDefinitionContext)_localctx)._types.Add(((FunctionDefinitionContext)_localctx)._type);
					State = 50;
					((FunctionDefinitionContext)_localctx)._ID = Match(ID);
					((FunctionDefinitionContext)_localctx)._params.Add(((FunctionDefinitionContext)_localctx)._ID);
					State = 57;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					while (_la==T__1) {
						{
						{
						State = 51;
						Match(T__1);
						State = 52;
						((FunctionDefinitionContext)_localctx)._type = type(0);
						((FunctionDefinitionContext)_localctx)._types.Add(((FunctionDefinitionContext)_localctx)._type);
						State = 53;
						((FunctionDefinitionContext)_localctx)._ID = Match(ID);
						((FunctionDefinitionContext)_localctx)._params.Add(((FunctionDefinitionContext)_localctx)._ID);
						}
						}
						State = 59;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
					}
					}
				}

				State = 62;
				Match(T__2);
				State = 63;
				block();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BlockContext : Q1.Compiler.Context {
		[System.Diagnostics.DebuggerNonUserCode] public Block_itemContext[] block_item() {
			return GetRuleContexts<Block_itemContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Block_itemContext block_item(int i) {
			return GetRuleContext<Block_itemContext>(i);
		}
		public BlockContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_block; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBlock(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public BlockContext block() {
		BlockContext _localctx = new BlockContext(Context, State);
		EnterRule(_localctx, 4, RULE_block);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 67;
			Match(T__4);
			State = 71;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 7196752204571180466L) != 0)) {
				{
				{
				State = 68;
				block_item();
				}
				}
				State = 73;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 74;
			Match(T__5);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Block_itemContext : Q1.Compiler.Context {
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext statement() {
			return GetRuleContext<StatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DeclarationContext declaration() {
			return GetRuleContext<DeclarationContext>(0);
		}
		public Block_itemContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_block_item; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBlock_item(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Block_itemContext block_item() {
		Block_itemContext _localctx = new Block_itemContext(Context, State);
		EnterRule(_localctx, 6, RULE_block_item);
		try {
			State = 78;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__0:
			case T__3:
			case T__4:
			case T__6:
			case T__7:
			case T__9:
			case T__10:
			case T__11:
			case T__12:
			case T__13:
			case T__15:
			case T__18:
			case T__19:
			case T__20:
			case T__21:
			case T__22:
			case T__23:
			case HEX:
			case ID:
			case INT:
			case LETTER:
			case STRING:
				EnterOuterAlt(_localctx, 1);
				{
				State = 76;
				statement();
				}
				break;
			case T__52:
			case T__53:
				EnterOuterAlt(_localctx, 2);
				{
				State = 77;
				declaration();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class StatementContext : Q1.Compiler.Context {
		public StatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_statement; } }
	 
		public StatementContext() { }
		public virtual void CopyFrom(StatementContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class WhileStatementContext : StatementContext {
		public ExpressionContext cond;
		public StatementContext body;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext statement() {
			return GetRuleContext<StatementContext>(0);
		}
		public WhileStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitWhileStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ForDeclStatementContext : StatementContext {
		public DeclarationContext initializer;
		public ExpressionContext cond;
		public ExpressionContext post;
		public StatementContext body;
		[System.Diagnostics.DebuggerNonUserCode] public DeclarationContext declaration() {
			return GetRuleContext<DeclarationContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext statement() {
			return GetRuleContext<StatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ForDeclStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitForDeclStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class BlockStatementContext : StatementContext {
		[System.Diagnostics.DebuggerNonUserCode] public BlockContext block() {
			return GetRuleContext<BlockContext>(0);
		}
		public BlockStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBlockStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class NullStatementContext : StatementContext {
		public NullStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNullStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ForExprStatementContext : StatementContext {
		public ExpressionContext initializer;
		public ExpressionContext cond;
		public ExpressionContext post;
		public StatementContext body;
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext statement() {
			return GetRuleContext<StatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ForExprStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitForExprStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class BreakStatementContext : StatementContext {
		public BreakStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBreakStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class DoWhileStatementContext : StatementContext {
		public StatementContext body;
		public ExpressionContext cond;
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext statement() {
			return GetRuleContext<StatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public DoWhileStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDoWhileStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ContinueStatementContext : StatementContext {
		public ContinueStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitContinueStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpressionStatementContext : StatementContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ExpressionStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpressionStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ReturnStatementContext : StatementContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ReturnStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitReturnStatement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class IfStatementContext : StatementContext {
		public StatementContext then;
		public StatementContext @else;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext[] statement() {
			return GetRuleContexts<StatementContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext statement(int i) {
			return GetRuleContext<StatementContext>(i);
		}
		public IfStatementContext(StatementContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIfStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StatementContext statement() {
		StatementContext _localctx = new StatementContext(Context, State);
		EnterRule(_localctx, 8, RULE_statement);
		int _la;
		try {
			State = 144;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,14,Context) ) {
			case 1:
				_localctx = new ReturnStatementContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 80;
				Match(T__6);
				State = 81;
				expression(0);
				State = 82;
				Match(T__3);
				}
				break;
			case 2:
				_localctx = new IfStatementContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 84;
				Match(T__7);
				State = 85;
				Match(T__0);
				State = 86;
				expression(0);
				State = 87;
				Match(T__2);
				State = 88;
				((IfStatementContext)_localctx).then = statement();
				State = 91;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,8,Context) ) {
				case 1:
					{
					State = 89;
					Match(T__8);
					State = 90;
					((IfStatementContext)_localctx).@else = statement();
					}
					break;
				}
				}
				break;
			case 3:
				_localctx = new ForExprStatementContext(_localctx);
				EnterOuterAlt(_localctx, 3);
				{
				State = 93;
				Match(T__9);
				State = 94;
				Match(T__0);
				State = 96;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 7169730606806925314L) != 0)) {
					{
					State = 95;
					((ForExprStatementContext)_localctx).initializer = expression(0);
					}
				}

				State = 98;
				Match(T__3);
				State = 100;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 7169730606806925314L) != 0)) {
					{
					State = 99;
					((ForExprStatementContext)_localctx).cond = expression(0);
					}
				}

				State = 102;
				Match(T__3);
				State = 104;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 7169730606806925314L) != 0)) {
					{
					State = 103;
					((ForExprStatementContext)_localctx).post = expression(0);
					}
				}

				State = 106;
				Match(T__2);
				State = 107;
				((ForExprStatementContext)_localctx).body = statement();
				}
				break;
			case 4:
				_localctx = new ForDeclStatementContext(_localctx);
				EnterOuterAlt(_localctx, 4);
				{
				State = 108;
				Match(T__9);
				State = 109;
				Match(T__0);
				State = 110;
				((ForDeclStatementContext)_localctx).initializer = declaration();
				State = 112;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 7169730606806925314L) != 0)) {
					{
					State = 111;
					((ForDeclStatementContext)_localctx).cond = expression(0);
					}
				}

				State = 114;
				Match(T__3);
				State = 116;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 7169730606806925314L) != 0)) {
					{
					State = 115;
					((ForDeclStatementContext)_localctx).post = expression(0);
					}
				}

				State = 118;
				Match(T__2);
				State = 119;
				((ForDeclStatementContext)_localctx).body = statement();
				}
				break;
			case 5:
				_localctx = new WhileStatementContext(_localctx);
				EnterOuterAlt(_localctx, 5);
				{
				State = 121;
				Match(T__10);
				State = 122;
				Match(T__0);
				State = 123;
				((WhileStatementContext)_localctx).cond = expression(0);
				State = 124;
				Match(T__2);
				State = 125;
				((WhileStatementContext)_localctx).body = statement();
				}
				break;
			case 6:
				_localctx = new DoWhileStatementContext(_localctx);
				EnterOuterAlt(_localctx, 6);
				{
				State = 127;
				Match(T__11);
				State = 128;
				((DoWhileStatementContext)_localctx).body = statement();
				State = 129;
				Match(T__10);
				State = 130;
				Match(T__0);
				State = 131;
				((DoWhileStatementContext)_localctx).cond = expression(0);
				State = 132;
				Match(T__2);
				State = 133;
				Match(T__3);
				}
				break;
			case 7:
				_localctx = new BreakStatementContext(_localctx);
				EnterOuterAlt(_localctx, 7);
				{
				State = 135;
				Match(T__12);
				State = 136;
				Match(T__3);
				}
				break;
			case 8:
				_localctx = new ContinueStatementContext(_localctx);
				EnterOuterAlt(_localctx, 8);
				{
				State = 137;
				Match(T__13);
				State = 138;
				Match(T__3);
				}
				break;
			case 9:
				_localctx = new ExpressionStatementContext(_localctx);
				EnterOuterAlt(_localctx, 9);
				{
				State = 139;
				expression(0);
				State = 140;
				Match(T__3);
				}
				break;
			case 10:
				_localctx = new BlockStatementContext(_localctx);
				EnterOuterAlt(_localctx, 10);
				{
				State = 142;
				block();
				}
				break;
			case 11:
				_localctx = new NullStatementContext(_localctx);
				EnterOuterAlt(_localctx, 11);
				{
				State = 143;
				Match(T__3);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DeclarationContext : Q1.Compiler.Context {
		public DeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_declaration; } }
	 
		public DeclarationContext() { }
		public virtual void CopyFrom(DeclarationContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class VariableDeclarationContext : DeclarationContext {
		public IToken name;
		public ExpressionContext value;
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CGrammarParser.ID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public VariableDeclarationContext(DeclarationContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariableDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DeclarationContext declaration() {
		DeclarationContext _localctx = new DeclarationContext(Context, State);
		EnterRule(_localctx, 10, RULE_declaration);
		int _la;
		try {
			_localctx = new VariableDeclarationContext(_localctx);
			EnterOuterAlt(_localctx, 1);
			{
			State = 146;
			type(0);
			State = 147;
			((VariableDeclarationContext)_localctx).name = Match(ID);
			State = 150;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==T__14) {
				{
				State = 148;
				Match(T__14);
				State = 149;
				((VariableDeclarationContext)_localctx).value = expression(0);
				}
			}

			State = 152;
			Match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExpressionContext : Q1.Compiler.Context {
		public ExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expression; } }
	 
		public ExpressionContext() { }
		public virtual void CopyFrom(ExpressionContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class AddressOfExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		public AddressOfExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAddressOfExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundSubtractExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundSubtractExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundSubtractExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ModulusExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ModulusExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitModulusExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class NotExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public NotExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNotExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class DecrementPrefixExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		public DecrementPrefixExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDecrementPrefixExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class MultiplyExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public MultiplyExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiplyExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class GreaterThanExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public GreaterThanExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitGreaterThanExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class BitwiseLeftShiftExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public BitwiseLeftShiftExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBitwiseLeftShiftExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class BitwiseRightShiftExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public BitwiseRightShiftExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBitwiseRightShiftExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class VariableExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CGrammarParser.ID, 0); }
		public VariableExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariableExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundDivideExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundDivideExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundDivideExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ParenthesizedExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ParenthesizedExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitParenthesizedExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundAddExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundAddExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundAddExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundMultiplyExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundMultiplyExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundMultiplyExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundBitwiseXorExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundBitwiseXorExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundBitwiseXorExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class BitwiseAndExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public BitwiseAndExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBitwiseAndExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class LessThanExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public LessThanExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLessThanExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class LogicalAndExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public LogicalAndExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLogicalAndExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class IndexExpressionContext : ExpressionContext {
		public TargetContext obj;
		public ExpressionContext indexer;
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public IndexExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIndexExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class InvertExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public InvertExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInvertExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class DereferenceExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public DereferenceExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDereferenceExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class EqualExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public EqualExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitEqualExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class BitwiseXorExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public BitwiseXorExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBitwiseXorExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ArrayExpressionContext : ExpressionContext {
		public ExpressionContext _expression;
		public IList<ExpressionContext> _params = new List<ExpressionContext>();
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CGrammarParser.INT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ArrayExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitArrayExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ConstantExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ConstantContext constant() {
			return GetRuleContext<ConstantContext>(0);
		}
		public ConstantExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitConstantExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundModulusExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundModulusExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundModulusExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class LessThanOrEqualExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public LessThanOrEqualExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLessThanOrEqualExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class IncrementPostfixExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		public IncrementPostfixExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIncrementPostfixExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundBitwiseRightShiftExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundBitwiseRightShiftExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundBitwiseRightShiftExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class AssignmentExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public AssignmentExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAssignmentExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class NotEqualExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public NotEqualExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNotEqualExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundBitwiseAndExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundBitwiseAndExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundBitwiseAndExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class LogicalOrExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public LogicalOrExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLogicalOrExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class IncrementPrefixExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		public IncrementPrefixExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIncrementPrefixExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class GreaterThanOrEqualExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public GreaterThanOrEqualExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitGreaterThanOrEqualExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class DivideExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public DivideExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDivideExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class BitwiseOrExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public BitwiseOrExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBitwiseOrExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CallExpressionContext : ExpressionContext {
		public ExpressionContext _expression;
		public IList<ExpressionContext> _params = new List<ExpressionContext>();
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CGrammarParser.ID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public CallExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCallExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class AddExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public AddExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAddExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class SubtractExpressionContext : ExpressionContext {
		public ExpressionContext left;
		public ExpressionContext right;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public SubtractExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSubtractExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundBitwiseOrExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundBitwiseOrExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundBitwiseOrExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class DecrementPostfixExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		public DecrementPostfixExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDecrementPostfixExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class TernaryExpressionContext : ExpressionContext {
		public ExpressionContext cond;
		public ExpressionContext then;
		public ExpressionContext @else;
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public TernaryExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTernaryExpression(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class CompoundBitwiseLeftShiftExpressionContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public CompoundBitwiseLeftShiftExpressionContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompoundBitwiseLeftShiftExpression(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExpressionContext expression() {
		return expression(0);
	}

	private ExpressionContext expression(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		ExpressionContext _localctx = new ExpressionContext(Context, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 12;
		EnterRecursionRule(_localctx, 12, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 262;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,22,Context) ) {
			case 1:
				{
				_localctx = new ParenthesizedExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;

				State = 155;
				Match(T__0);
				State = 156;
				expression(0);
				State = 157;
				Match(T__2);
				}
				break;
			case 2:
				{
				_localctx = new ArrayExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 159;
				Match(T__15);
				State = 160;
				type(0);
				State = 161;
				Match(T__16);
				State = 163;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==INT) {
					{
					State = 162;
					Match(INT);
					}
				}

				State = 165;
				Match(T__17);
				State = 178;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) {
				case 1:
					{
					State = 166;
					Match(T__4);
					State = 175;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 7169730606806925314L) != 0)) {
						{
						State = 167;
						((ArrayExpressionContext)_localctx)._expression = expression(0);
						((ArrayExpressionContext)_localctx)._params.Add(((ArrayExpressionContext)_localctx)._expression);
						State = 172;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
						while (_la==T__1) {
							{
							{
							State = 168;
							Match(T__1);
							State = 169;
							((ArrayExpressionContext)_localctx)._expression = expression(0);
							((ArrayExpressionContext)_localctx)._params.Add(((ArrayExpressionContext)_localctx)._expression);
							}
							}
							State = 174;
							ErrorHandler.Sync(this);
							_la = TokenStream.LA(1);
						}
						}
					}

					State = 177;
					Match(T__5);
					}
					break;
				}
				}
				break;
			case 3:
				{
				_localctx = new ConstantExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 180;
				constant();
				}
				break;
			case 4:
				{
				_localctx = new AssignmentExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 181;
				target(0);
				State = 182;
				Match(T__14);
				State = 183;
				expression(41);
				}
				break;
			case 5:
				{
				_localctx = new DereferenceExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 185;
				Match(T__18);
				State = 186;
				expression(40);
				}
				break;
			case 6:
				{
				_localctx = new AddressOfExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 187;
				Match(T__19);
				State = 188;
				target(0);
				}
				break;
			case 7:
				{
				_localctx = new VariableExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 189;
				Match(ID);
				}
				break;
			case 8:
				{
				_localctx = new CallExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 190;
				Match(ID);
				State = 191;
				Match(T__0);
				State = 200;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 7169730606806925314L) != 0)) {
					{
					State = 192;
					((CallExpressionContext)_localctx)._expression = expression(0);
					((CallExpressionContext)_localctx)._params.Add(((CallExpressionContext)_localctx)._expression);
					State = 197;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					while (_la==T__1) {
						{
						{
						State = 193;
						Match(T__1);
						State = 194;
						((CallExpressionContext)_localctx)._expression = expression(0);
						((CallExpressionContext)_localctx)._params.Add(((CallExpressionContext)_localctx)._expression);
						}
						}
						State = 199;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
					}
					}
				}

				State = 202;
				Match(T__2);
				}
				break;
			case 9:
				{
				_localctx = new IndexExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 203;
				((IndexExpressionContext)_localctx).obj = target(0);
				State = 204;
				Match(T__16);
				State = 205;
				((IndexExpressionContext)_localctx).indexer = expression(0);
				State = 206;
				Match(T__17);
				}
				break;
			case 10:
				{
				_localctx = new NotExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 208;
				Match(T__20);
				State = 209;
				expression(35);
				}
				break;
			case 11:
				{
				_localctx = new InvertExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 210;
				Match(T__21);
				State = 211;
				expression(34);
				}
				break;
			case 12:
				{
				_localctx = new IncrementPrefixExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 212;
				Match(T__22);
				State = 213;
				target(0);
				}
				break;
			case 13:
				{
				_localctx = new DecrementPrefixExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 214;
				Match(T__23);
				State = 215;
				target(0);
				}
				break;
			case 14:
				{
				_localctx = new IncrementPostfixExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 216;
				target(0);
				State = 217;
				Match(T__22);
				}
				break;
			case 15:
				{
				_localctx = new DecrementPostfixExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 219;
				target(0);
				State = 220;
				Match(T__23);
				}
				break;
			case 16:
				{
				_localctx = new CompoundMultiplyExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 222;
				target(0);
				State = 223;
				Match(T__40);
				State = 224;
				expression(11);
				}
				break;
			case 17:
				{
				_localctx = new CompoundDivideExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 226;
				target(0);
				State = 227;
				Match(T__41);
				State = 228;
				expression(10);
				}
				break;
			case 18:
				{
				_localctx = new CompoundModulusExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 230;
				target(0);
				State = 231;
				Match(T__42);
				State = 232;
				expression(9);
				}
				break;
			case 19:
				{
				_localctx = new CompoundAddExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 234;
				target(0);
				State = 235;
				Match(T__43);
				State = 236;
				expression(8);
				}
				break;
			case 20:
				{
				_localctx = new CompoundSubtractExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 238;
				target(0);
				State = 239;
				Match(T__44);
				State = 240;
				expression(7);
				}
				break;
			case 21:
				{
				_localctx = new CompoundBitwiseAndExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 242;
				target(0);
				State = 243;
				Match(T__45);
				State = 244;
				expression(6);
				}
				break;
			case 22:
				{
				_localctx = new CompoundBitwiseOrExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 246;
				target(0);
				State = 247;
				Match(T__46);
				State = 248;
				expression(5);
				}
				break;
			case 23:
				{
				_localctx = new CompoundBitwiseXorExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 250;
				target(0);
				State = 251;
				Match(T__47);
				State = 252;
				expression(4);
				}
				break;
			case 24:
				{
				_localctx = new CompoundBitwiseLeftShiftExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 254;
				target(0);
				State = 255;
				Match(T__48);
				State = 256;
				expression(3);
				}
				break;
			case 25:
				{
				_localctx = new CompoundBitwiseRightShiftExpressionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 258;
				target(0);
				State = 259;
				Match(T__49);
				State = 260;
				expression(2);
				}
				break;
			}
			Context.Stop = TokenStream.LT(-1);
			State = 326;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,24,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 324;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,23,Context) ) {
					case 1:
						{
						_localctx = new MultiplyExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((MultiplyExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 264;
						if (!(Precpred(Context, 29))) throw new FailedPredicateException(this, "Precpred(Context, 29)");
						State = 265;
						Match(T__18);
						State = 266;
						((MultiplyExpressionContext)_localctx).right = expression(30);
						}
						break;
					case 2:
						{
						_localctx = new DivideExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((DivideExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 267;
						if (!(Precpred(Context, 28))) throw new FailedPredicateException(this, "Precpred(Context, 28)");
						State = 268;
						Match(T__24);
						State = 269;
						((DivideExpressionContext)_localctx).right = expression(29);
						}
						break;
					case 3:
						{
						_localctx = new ModulusExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((ModulusExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 270;
						if (!(Precpred(Context, 27))) throw new FailedPredicateException(this, "Precpred(Context, 27)");
						State = 271;
						Match(T__25);
						State = 272;
						((ModulusExpressionContext)_localctx).right = expression(28);
						}
						break;
					case 4:
						{
						_localctx = new AddExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((AddExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 273;
						if (!(Precpred(Context, 26))) throw new FailedPredicateException(this, "Precpred(Context, 26)");
						State = 274;
						Match(T__26);
						State = 275;
						((AddExpressionContext)_localctx).right = expression(27);
						}
						break;
					case 5:
						{
						_localctx = new SubtractExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((SubtractExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 276;
						if (!(Precpred(Context, 25))) throw new FailedPredicateException(this, "Precpred(Context, 25)");
						State = 277;
						Match(T__27);
						State = 278;
						((SubtractExpressionContext)_localctx).right = expression(26);
						}
						break;
					case 6:
						{
						_localctx = new LessThanExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((LessThanExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 279;
						if (!(Precpred(Context, 24))) throw new FailedPredicateException(this, "Precpred(Context, 24)");
						State = 280;
						Match(T__28);
						State = 281;
						((LessThanExpressionContext)_localctx).right = expression(25);
						}
						break;
					case 7:
						{
						_localctx = new GreaterThanExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((GreaterThanExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 282;
						if (!(Precpred(Context, 23))) throw new FailedPredicateException(this, "Precpred(Context, 23)");
						State = 283;
						Match(T__29);
						State = 284;
						((GreaterThanExpressionContext)_localctx).right = expression(24);
						}
						break;
					case 8:
						{
						_localctx = new LessThanOrEqualExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((LessThanOrEqualExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 285;
						if (!(Precpred(Context, 22))) throw new FailedPredicateException(this, "Precpred(Context, 22)");
						State = 286;
						Match(T__30);
						State = 287;
						((LessThanOrEqualExpressionContext)_localctx).right = expression(23);
						}
						break;
					case 9:
						{
						_localctx = new GreaterThanOrEqualExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((GreaterThanOrEqualExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 288;
						if (!(Precpred(Context, 21))) throw new FailedPredicateException(this, "Precpred(Context, 21)");
						State = 289;
						Match(T__31);
						State = 290;
						((GreaterThanOrEqualExpressionContext)_localctx).right = expression(22);
						}
						break;
					case 10:
						{
						_localctx = new EqualExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((EqualExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 291;
						if (!(Precpred(Context, 20))) throw new FailedPredicateException(this, "Precpred(Context, 20)");
						State = 292;
						Match(T__32);
						State = 293;
						((EqualExpressionContext)_localctx).right = expression(21);
						}
						break;
					case 11:
						{
						_localctx = new NotEqualExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((NotEqualExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 294;
						if (!(Precpred(Context, 19))) throw new FailedPredicateException(this, "Precpred(Context, 19)");
						State = 295;
						Match(T__33);
						State = 296;
						((NotEqualExpressionContext)_localctx).right = expression(20);
						}
						break;
					case 12:
						{
						_localctx = new BitwiseAndExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((BitwiseAndExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 297;
						if (!(Precpred(Context, 18))) throw new FailedPredicateException(this, "Precpred(Context, 18)");
						State = 298;
						Match(T__19);
						State = 299;
						((BitwiseAndExpressionContext)_localctx).right = expression(19);
						}
						break;
					case 13:
						{
						_localctx = new BitwiseOrExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((BitwiseOrExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 300;
						if (!(Precpred(Context, 17))) throw new FailedPredicateException(this, "Precpred(Context, 17)");
						State = 301;
						Match(T__34);
						State = 302;
						((BitwiseOrExpressionContext)_localctx).right = expression(18);
						}
						break;
					case 14:
						{
						_localctx = new BitwiseXorExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((BitwiseXorExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 303;
						if (!(Precpred(Context, 16))) throw new FailedPredicateException(this, "Precpred(Context, 16)");
						State = 304;
						Match(T__35);
						State = 305;
						((BitwiseXorExpressionContext)_localctx).right = expression(17);
						}
						break;
					case 15:
						{
						_localctx = new BitwiseLeftShiftExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((BitwiseLeftShiftExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 306;
						if (!(Precpred(Context, 15))) throw new FailedPredicateException(this, "Precpred(Context, 15)");
						State = 307;
						Match(T__36);
						State = 308;
						((BitwiseLeftShiftExpressionContext)_localctx).right = expression(16);
						}
						break;
					case 16:
						{
						_localctx = new BitwiseRightShiftExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((BitwiseRightShiftExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 309;
						if (!(Precpred(Context, 14))) throw new FailedPredicateException(this, "Precpred(Context, 14)");
						State = 310;
						Match(T__37);
						State = 311;
						((BitwiseRightShiftExpressionContext)_localctx).right = expression(15);
						}
						break;
					case 17:
						{
						_localctx = new LogicalAndExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((LogicalAndExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 312;
						if (!(Precpred(Context, 13))) throw new FailedPredicateException(this, "Precpred(Context, 13)");
						State = 313;
						Match(T__38);
						State = 314;
						((LogicalAndExpressionContext)_localctx).right = expression(14);
						}
						break;
					case 18:
						{
						_localctx = new LogicalOrExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((LogicalOrExpressionContext)_localctx).left = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 315;
						if (!(Precpred(Context, 12))) throw new FailedPredicateException(this, "Precpred(Context, 12)");
						State = 316;
						Match(T__39);
						State = 317;
						((LogicalOrExpressionContext)_localctx).right = expression(13);
						}
						break;
					case 19:
						{
						_localctx = new TernaryExpressionContext(new ExpressionContext(_parentctx, _parentState));
						((TernaryExpressionContext)_localctx).cond = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 318;
						if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)");
						State = 319;
						Match(T__50);
						State = 320;
						((TernaryExpressionContext)_localctx).then = expression(0);
						State = 321;
						Match(T__51);
						State = 322;
						((TernaryExpressionContext)_localctx).@else = expression(2);
						}
						break;
					}
					} 
				}
				State = 328;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,24,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public partial class ConstantContext : Q1.Compiler.Context {
		public ConstantContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_constant; } }
	 
		public ConstantContext() { }
		public virtual void CopyFrom(ConstantContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class CharConstantContext : ConstantContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LETTER() { return GetToken(CGrammarParser.LETTER, 0); }
		public CharConstantContext(ConstantContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCharConstant(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class IntConstantContext : ConstantContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CGrammarParser.INT, 0); }
		public IntConstantContext(ConstantContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIntConstant(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class StringConstantContext : ConstantContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(CGrammarParser.STRING, 0); }
		public StringConstantContext(ConstantContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStringConstant(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class HexConstantContext : ConstantContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HEX() { return GetToken(CGrammarParser.HEX, 0); }
		public HexConstantContext(ConstantContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHexConstant(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ConstantContext constant() {
		ConstantContext _localctx = new ConstantContext(Context, State);
		EnterRule(_localctx, 14, RULE_constant);
		try {
			State = 333;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case INT:
				_localctx = new IntConstantContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 329;
				Match(INT);
				}
				break;
			case HEX:
				_localctx = new HexConstantContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 330;
				Match(HEX);
				}
				break;
			case LETTER:
				_localctx = new CharConstantContext(_localctx);
				EnterOuterAlt(_localctx, 3);
				{
				State = 331;
				Match(LETTER);
				}
				break;
			case STRING:
				_localctx = new StringConstantContext(_localctx);
				EnterOuterAlt(_localctx, 4);
				{
				State = 332;
				Match(STRING);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypeContext : Q1.Compiler.Context {
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		public TypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_type; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TypeContext type() {
		return type(0);
	}

	private TypeContext type(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		TypeContext _localctx = new TypeContext(Context, _parentState);
		TypeContext _prevctx = _localctx;
		int _startState = 16;
		EnterRecursionRule(_localctx, 16, RULE_type, _p);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 338;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__52:
				{
				State = 336;
				Match(T__52);
				}
				break;
			case T__53:
				{
				State = 337;
				Match(T__53);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			Context.Stop = TokenStream.LT(-1);
			State = 344;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,27,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new TypeContext(_parentctx, _parentState);
					PushNewRecursionContext(_localctx, _startState, RULE_type);
					State = 340;
					if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)");
					State = 341;
					Match(T__18);
					}
					} 
				}
				State = 346;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,27,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public partial class TargetContext : Q1.Compiler.Context {
		public TargetContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_target; } }
	 
		public TargetContext() { }
		public virtual void CopyFrom(TargetContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class IndexerTargetContext : TargetContext {
		public TargetContext obj;
		public ExpressionContext indexer;
		[System.Diagnostics.DebuggerNonUserCode] public TargetContext target() {
			return GetRuleContext<TargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public IndexerTargetContext(TargetContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIndexerTarget(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class VariableTargetContext : TargetContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CGrammarParser.ID, 0); }
		public VariableTargetContext(TargetContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICGrammarVisitor<TResult> typedVisitor = visitor as ICGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariableTarget(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TargetContext target() {
		return target(0);
	}

	private TargetContext target(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		TargetContext _localctx = new TargetContext(Context, _parentState);
		TargetContext _prevctx = _localctx;
		int _startState = 18;
		EnterRecursionRule(_localctx, 18, RULE_target, _p);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			{
			_localctx = new VariableTargetContext(_localctx);
			Context = _localctx;
			_prevctx = _localctx;

			State = 348;
			Match(ID);
			}
			Context.Stop = TokenStream.LT(-1);
			State = 357;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,28,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new IndexerTargetContext(new TargetContext(_parentctx, _parentState));
					((IndexerTargetContext)_localctx).obj = _prevctx;
					PushNewRecursionContext(_localctx, _startState, RULE_target);
					State = 350;
					if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)");
					State = 351;
					Match(T__16);
					State = 352;
					((IndexerTargetContext)_localctx).indexer = expression(0);
					State = 353;
					Match(T__17);
					}
					} 
				}
				State = 359;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,28,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 6: return expression_sempred((ExpressionContext)_localctx, predIndex);
		case 8: return type_sempred((TypeContext)_localctx, predIndex);
		case 9: return target_sempred((TargetContext)_localctx, predIndex);
		}
		return true;
	}
	private bool expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return Precpred(Context, 29);
		case 1: return Precpred(Context, 28);
		case 2: return Precpred(Context, 27);
		case 3: return Precpred(Context, 26);
		case 4: return Precpred(Context, 25);
		case 5: return Precpred(Context, 24);
		case 6: return Precpred(Context, 23);
		case 7: return Precpred(Context, 22);
		case 8: return Precpred(Context, 21);
		case 9: return Precpred(Context, 20);
		case 10: return Precpred(Context, 19);
		case 11: return Precpred(Context, 18);
		case 12: return Precpred(Context, 17);
		case 13: return Precpred(Context, 16);
		case 14: return Precpred(Context, 15);
		case 15: return Precpred(Context, 14);
		case 16: return Precpred(Context, 13);
		case 17: return Precpred(Context, 12);
		case 18: return Precpred(Context, 1);
		}
		return true;
	}
	private bool type_sempred(TypeContext _localctx, int predIndex) {
		switch (predIndex) {
		case 19: return Precpred(Context, 1);
		}
		return true;
	}
	private bool target_sempred(TargetContext _localctx, int predIndex) {
		switch (predIndex) {
		case 20: return Precpred(Context, 1);
		}
		return true;
	}

	private static int[] _serializedATN = {
		4,1,62,361,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,7,
		7,7,2,8,7,8,2,9,7,9,1,0,4,0,22,8,0,11,0,12,0,23,1,0,1,0,1,1,1,1,1,1,1,
		1,1,1,1,1,1,1,1,1,1,1,5,1,37,8,1,10,1,12,1,40,9,1,3,1,42,8,1,1,1,1,1,1,
		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,56,8,1,10,1,12,1,59,9,1,3,1,
		61,8,1,1,1,1,1,1,1,3,1,66,8,1,1,2,1,2,5,2,70,8,2,10,2,12,2,73,9,2,1,2,
		1,2,1,3,1,3,3,3,79,8,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,
		92,8,4,1,4,1,4,1,4,3,4,97,8,4,1,4,1,4,3,4,101,8,4,1,4,1,4,3,4,105,8,4,
		1,4,1,4,1,4,1,4,1,4,1,4,3,4,113,8,4,1,4,1,4,3,4,117,8,4,1,4,1,4,1,4,1,
		4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,
		1,4,1,4,1,4,1,4,1,4,3,4,145,8,4,1,5,1,5,1,5,1,5,3,5,151,8,5,1,5,1,5,1,
		6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,164,8,6,1,6,1,6,1,6,1,6,1,6,5,6,
		171,8,6,10,6,12,6,174,9,6,3,6,176,8,6,1,6,3,6,179,8,6,1,6,1,6,1,6,1,6,
		1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,5,6,196,8,6,10,6,12,6,199,
		9,6,3,6,201,8,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,
		6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,
		1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,
		6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,263,8,6,1,6,1,6,1,6,
		1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,
		6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,
		1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,
		6,1,6,1,6,1,6,1,6,5,6,325,8,6,10,6,12,6,328,9,6,1,7,1,7,1,7,1,7,3,7,334,
		8,7,1,8,1,8,1,8,3,8,339,8,8,1,8,1,8,5,8,343,8,8,10,8,12,8,346,9,8,1,9,
		1,9,1,9,1,9,1,9,1,9,1,9,1,9,5,9,356,8,9,10,9,12,9,359,9,9,1,9,0,3,12,16,
		18,10,0,2,4,6,8,10,12,14,16,18,0,0,430,0,21,1,0,0,0,2,65,1,0,0,0,4,67,
		1,0,0,0,6,78,1,0,0,0,8,144,1,0,0,0,10,146,1,0,0,0,12,262,1,0,0,0,14,333,
		1,0,0,0,16,338,1,0,0,0,18,347,1,0,0,0,20,22,3,2,1,0,21,20,1,0,0,0,22,23,
		1,0,0,0,23,21,1,0,0,0,23,24,1,0,0,0,24,25,1,0,0,0,25,26,5,0,0,1,26,1,1,
		0,0,0,27,28,3,16,8,0,28,29,5,56,0,0,29,41,5,1,0,0,30,31,3,16,8,0,31,38,
		5,56,0,0,32,33,5,2,0,0,33,34,3,16,8,0,34,35,5,56,0,0,35,37,1,0,0,0,36,
		32,1,0,0,0,37,40,1,0,0,0,38,36,1,0,0,0,38,39,1,0,0,0,39,42,1,0,0,0,40,
		38,1,0,0,0,41,30,1,0,0,0,41,42,1,0,0,0,42,43,1,0,0,0,43,44,5,3,0,0,44,
		45,5,4,0,0,45,66,1,0,0,0,46,47,3,16,8,0,47,48,5,56,0,0,48,60,5,1,0,0,49,
		50,3,16,8,0,50,57,5,56,0,0,51,52,5,2,0,0,52,53,3,16,8,0,53,54,5,56,0,0,
		54,56,1,0,0,0,55,51,1,0,0,0,56,59,1,0,0,0,57,55,1,0,0,0,57,58,1,0,0,0,
		58,61,1,0,0,0,59,57,1,0,0,0,60,49,1,0,0,0,60,61,1,0,0,0,61,62,1,0,0,0,
		62,63,5,3,0,0,63,64,3,4,2,0,64,66,1,0,0,0,65,27,1,0,0,0,65,46,1,0,0,0,
		66,3,1,0,0,0,67,71,5,5,0,0,68,70,3,6,3,0,69,68,1,0,0,0,70,73,1,0,0,0,71,
		69,1,0,0,0,71,72,1,0,0,0,72,74,1,0,0,0,73,71,1,0,0,0,74,75,5,6,0,0,75,
		5,1,0,0,0,76,79,3,8,4,0,77,79,3,10,5,0,78,76,1,0,0,0,78,77,1,0,0,0,79,
		7,1,0,0,0,80,81,5,7,0,0,81,82,3,12,6,0,82,83,5,4,0,0,83,145,1,0,0,0,84,
		85,5,8,0,0,85,86,5,1,0,0,86,87,3,12,6,0,87,88,5,3,0,0,88,91,3,8,4,0,89,
		90,5,9,0,0,90,92,3,8,4,0,91,89,1,0,0,0,91,92,1,0,0,0,92,145,1,0,0,0,93,
		94,5,10,0,0,94,96,5,1,0,0,95,97,3,12,6,0,96,95,1,0,0,0,96,97,1,0,0,0,97,
		98,1,0,0,0,98,100,5,4,0,0,99,101,3,12,6,0,100,99,1,0,0,0,100,101,1,0,0,
		0,101,102,1,0,0,0,102,104,5,4,0,0,103,105,3,12,6,0,104,103,1,0,0,0,104,
		105,1,0,0,0,105,106,1,0,0,0,106,107,5,3,0,0,107,145,3,8,4,0,108,109,5,
		10,0,0,109,110,5,1,0,0,110,112,3,10,5,0,111,113,3,12,6,0,112,111,1,0,0,
		0,112,113,1,0,0,0,113,114,1,0,0,0,114,116,5,4,0,0,115,117,3,12,6,0,116,
		115,1,0,0,0,116,117,1,0,0,0,117,118,1,0,0,0,118,119,5,3,0,0,119,120,3,
		8,4,0,120,145,1,0,0,0,121,122,5,11,0,0,122,123,5,1,0,0,123,124,3,12,6,
		0,124,125,5,3,0,0,125,126,3,8,4,0,126,145,1,0,0,0,127,128,5,12,0,0,128,
		129,3,8,4,0,129,130,5,11,0,0,130,131,5,1,0,0,131,132,3,12,6,0,132,133,
		5,3,0,0,133,134,5,4,0,0,134,145,1,0,0,0,135,136,5,13,0,0,136,145,5,4,0,
		0,137,138,5,14,0,0,138,145,5,4,0,0,139,140,3,12,6,0,140,141,5,4,0,0,141,
		145,1,0,0,0,142,145,3,4,2,0,143,145,5,4,0,0,144,80,1,0,0,0,144,84,1,0,
		0,0,144,93,1,0,0,0,144,108,1,0,0,0,144,121,1,0,0,0,144,127,1,0,0,0,144,
		135,1,0,0,0,144,137,1,0,0,0,144,139,1,0,0,0,144,142,1,0,0,0,144,143,1,
		0,0,0,145,9,1,0,0,0,146,147,3,16,8,0,147,150,5,56,0,0,148,149,5,15,0,0,
		149,151,3,12,6,0,150,148,1,0,0,0,150,151,1,0,0,0,151,152,1,0,0,0,152,153,
		5,4,0,0,153,11,1,0,0,0,154,155,6,6,-1,0,155,156,5,1,0,0,156,157,3,12,6,
		0,157,158,5,3,0,0,158,263,1,0,0,0,159,160,5,16,0,0,160,161,3,16,8,0,161,
		163,5,17,0,0,162,164,5,57,0,0,163,162,1,0,0,0,163,164,1,0,0,0,164,165,
		1,0,0,0,165,178,5,18,0,0,166,175,5,5,0,0,167,172,3,12,6,0,168,169,5,2,
		0,0,169,171,3,12,6,0,170,168,1,0,0,0,171,174,1,0,0,0,172,170,1,0,0,0,172,
		173,1,0,0,0,173,176,1,0,0,0,174,172,1,0,0,0,175,167,1,0,0,0,175,176,1,
		0,0,0,176,177,1,0,0,0,177,179,5,6,0,0,178,166,1,0,0,0,178,179,1,0,0,0,
		179,263,1,0,0,0,180,263,3,14,7,0,181,182,3,18,9,0,182,183,5,15,0,0,183,
		184,3,12,6,41,184,263,1,0,0,0,185,186,5,19,0,0,186,263,3,12,6,40,187,188,
		5,20,0,0,188,263,3,18,9,0,189,263,5,56,0,0,190,191,5,56,0,0,191,200,5,
		1,0,0,192,197,3,12,6,0,193,194,5,2,0,0,194,196,3,12,6,0,195,193,1,0,0,
		0,196,199,1,0,0,0,197,195,1,0,0,0,197,198,1,0,0,0,198,201,1,0,0,0,199,
		197,1,0,0,0,200,192,1,0,0,0,200,201,1,0,0,0,201,202,1,0,0,0,202,263,5,
		3,0,0,203,204,3,18,9,0,204,205,5,17,0,0,205,206,3,12,6,0,206,207,5,18,
		0,0,207,263,1,0,0,0,208,209,5,21,0,0,209,263,3,12,6,35,210,211,5,22,0,
		0,211,263,3,12,6,34,212,213,5,23,0,0,213,263,3,18,9,0,214,215,5,24,0,0,
		215,263,3,18,9,0,216,217,3,18,9,0,217,218,5,23,0,0,218,263,1,0,0,0,219,
		220,3,18,9,0,220,221,5,24,0,0,221,263,1,0,0,0,222,223,3,18,9,0,223,224,
		5,41,0,0,224,225,3,12,6,11,225,263,1,0,0,0,226,227,3,18,9,0,227,228,5,
		42,0,0,228,229,3,12,6,10,229,263,1,0,0,0,230,231,3,18,9,0,231,232,5,43,
		0,0,232,233,3,12,6,9,233,263,1,0,0,0,234,235,3,18,9,0,235,236,5,44,0,0,
		236,237,3,12,6,8,237,263,1,0,0,0,238,239,3,18,9,0,239,240,5,45,0,0,240,
		241,3,12,6,7,241,263,1,0,0,0,242,243,3,18,9,0,243,244,5,46,0,0,244,245,
		3,12,6,6,245,263,1,0,0,0,246,247,3,18,9,0,247,248,5,47,0,0,248,249,3,12,
		6,5,249,263,1,0,0,0,250,251,3,18,9,0,251,252,5,48,0,0,252,253,3,12,6,4,
		253,263,1,0,0,0,254,255,3,18,9,0,255,256,5,49,0,0,256,257,3,12,6,3,257,
		263,1,0,0,0,258,259,3,18,9,0,259,260,5,50,0,0,260,261,3,12,6,2,261,263,
		1,0,0,0,262,154,1,0,0,0,262,159,1,0,0,0,262,180,1,0,0,0,262,181,1,0,0,
		0,262,185,1,0,0,0,262,187,1,0,0,0,262,189,1,0,0,0,262,190,1,0,0,0,262,
		203,1,0,0,0,262,208,1,0,0,0,262,210,1,0,0,0,262,212,1,0,0,0,262,214,1,
		0,0,0,262,216,1,0,0,0,262,219,1,0,0,0,262,222,1,0,0,0,262,226,1,0,0,0,
		262,230,1,0,0,0,262,234,1,0,0,0,262,238,1,0,0,0,262,242,1,0,0,0,262,246,
		1,0,0,0,262,250,1,0,0,0,262,254,1,0,0,0,262,258,1,0,0,0,263,326,1,0,0,
		0,264,265,10,29,0,0,265,266,5,19,0,0,266,325,3,12,6,30,267,268,10,28,0,
		0,268,269,5,25,0,0,269,325,3,12,6,29,270,271,10,27,0,0,271,272,5,26,0,
		0,272,325,3,12,6,28,273,274,10,26,0,0,274,275,5,27,0,0,275,325,3,12,6,
		27,276,277,10,25,0,0,277,278,5,28,0,0,278,325,3,12,6,26,279,280,10,24,
		0,0,280,281,5,29,0,0,281,325,3,12,6,25,282,283,10,23,0,0,283,284,5,30,
		0,0,284,325,3,12,6,24,285,286,10,22,0,0,286,287,5,31,0,0,287,325,3,12,
		6,23,288,289,10,21,0,0,289,290,5,32,0,0,290,325,3,12,6,22,291,292,10,20,
		0,0,292,293,5,33,0,0,293,325,3,12,6,21,294,295,10,19,0,0,295,296,5,34,
		0,0,296,325,3,12,6,20,297,298,10,18,0,0,298,299,5,20,0,0,299,325,3,12,
		6,19,300,301,10,17,0,0,301,302,5,35,0,0,302,325,3,12,6,18,303,304,10,16,
		0,0,304,305,5,36,0,0,305,325,3,12,6,17,306,307,10,15,0,0,307,308,5,37,
		0,0,308,325,3,12,6,16,309,310,10,14,0,0,310,311,5,38,0,0,311,325,3,12,
		6,15,312,313,10,13,0,0,313,314,5,39,0,0,314,325,3,12,6,14,315,316,10,12,
		0,0,316,317,5,40,0,0,317,325,3,12,6,13,318,319,10,1,0,0,319,320,5,51,0,
		0,320,321,3,12,6,0,321,322,5,52,0,0,322,323,3,12,6,2,323,325,1,0,0,0,324,
		264,1,0,0,0,324,267,1,0,0,0,324,270,1,0,0,0,324,273,1,0,0,0,324,276,1,
		0,0,0,324,279,1,0,0,0,324,282,1,0,0,0,324,285,1,0,0,0,324,288,1,0,0,0,
		324,291,1,0,0,0,324,294,1,0,0,0,324,297,1,0,0,0,324,300,1,0,0,0,324,303,
		1,0,0,0,324,306,1,0,0,0,324,309,1,0,0,0,324,312,1,0,0,0,324,315,1,0,0,
		0,324,318,1,0,0,0,325,328,1,0,0,0,326,324,1,0,0,0,326,327,1,0,0,0,327,
		13,1,0,0,0,328,326,1,0,0,0,329,334,5,57,0,0,330,334,5,55,0,0,331,334,5,
		61,0,0,332,334,5,62,0,0,333,329,1,0,0,0,333,330,1,0,0,0,333,331,1,0,0,
		0,333,332,1,0,0,0,334,15,1,0,0,0,335,336,6,8,-1,0,336,339,5,53,0,0,337,
		339,5,54,0,0,338,335,1,0,0,0,338,337,1,0,0,0,339,344,1,0,0,0,340,341,10,
		1,0,0,341,343,5,19,0,0,342,340,1,0,0,0,343,346,1,0,0,0,344,342,1,0,0,0,
		344,345,1,0,0,0,345,17,1,0,0,0,346,344,1,0,0,0,347,348,6,9,-1,0,348,349,
		5,56,0,0,349,357,1,0,0,0,350,351,10,1,0,0,351,352,5,17,0,0,352,353,3,12,
		6,0,353,354,5,18,0,0,354,356,1,0,0,0,355,350,1,0,0,0,356,359,1,0,0,0,357,
		355,1,0,0,0,357,358,1,0,0,0,358,19,1,0,0,0,359,357,1,0,0,0,29,23,38,41,
		57,60,65,71,78,91,96,100,104,112,116,144,150,163,172,175,178,197,200,262,
		324,326,333,338,344,357
	};

	public static readonly ATN _ATN =
		new ATNDeserializer().Deserialize(_serializedATN);


}