Ptidej-v5.2-master/PADL Creator C# v1/src/padl/creator/csharpfile/v1/parser/CSharpParser.java
/*******************************************************************************
 * Copyright (c) 2001-2014 Yann-Gal Guhneuc and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * 
 * Contributors:
 *     Yann-Gal Guhneuc and others, see in file; API and its implementation
 ******************************************************************************/
// $ANTLR 3.1.3 Mar 18, 2009 10:09:25 ../rsc/CSharp.g3 2009-09-02 16:20:06

//package com.comarch.depth.csharp.parser.antlr;
package padl.creator.csharpfile.v1.parser;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.antlr.runtime.BaseRecognizer;
import org.antlr.runtime.DFA;
import org.antlr.runtime.EarlyExitException;
import org.antlr.runtime.IntStream;
import org.antlr.runtime.MismatchedSetException;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.Parser;
import org.antlr.runtime.ParserRuleReturnScope;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;
import org.antlr.runtime.Token;
import org.antlr.runtime.TokenStream;
import org.antlr.runtime.tree.CommonTreeAdaptor;
import org.antlr.runtime.tree.RewriteEarlyExitException;
import org.antlr.runtime.tree.RewriteRuleSubtreeStream;
import org.antlr.runtime.tree.RewriteRuleTokenStream;
import org.antlr.runtime.tree.TreeAdaptor;
import padl.csharp.kernel.ICSharpFactory;
import padl.kernel.IClass;
import padl.kernel.ICodeLevelModel;
import padl.kernel.IConstituentOfEntity;
import padl.kernel.IConstituentOfOperation;
import padl.kernel.IField;
import padl.kernel.IInterface;
import padl.kernel.IMethod;
import padl.kernel.IParameter;
import padl.kernel.exception.ModelDeclarationException;
import util.io.ProxyConsole;
import util.lang.Modifier;
//import padl.kernel.IDestructor;
//import padl.kernel.IGlobalField;

/**
 * This C# grammar is as close to the standard as possible. Most changes involve
 * the resolution of left recursion (direct and indirect).
 *
 * The tree produced contains all tokens (except whitespace, comments, preprocessor directives).
 * The tree structure is very close to the concrete syntax tree.
 *
 * Due to lexical ambiguities ( >> can be a rightshift of 2 closing angle brackets after a
 * nested type parameter) the 'lexical parser approach' as proposed on the ANTLR mailing
 * list has been used. By doubling the lexical rules in the parser, context can be used to
 * disambiguate. Whitespace and comment handling is also done in the parser part (rule
 * ignoredtail). Consider the whole construct a hack.
 
 * During the parsing nodes of named entities have their name assigned. Helper attributes
 * have been defined where necessary (e.g. name, signature, content). 
 * The content attribute has originally only been the predefined text attribute. However, 
 * after changing to the lexing parser approach this did not work anymore, because the 
 * text attribute does now not only contain the token text but also the text of the 
 * following ignoredtail. This is a hack introduced because of the lexing parser hack.
 *
 * Known issues:
 * - Casts and parenthesized expressions are ambiguous, 
 *   i.e. the following cases cannot be distinguished syntactically
 *   - (a)-x   :  cast of -x to a or the subtraction a - x
 *   In such a case the parser will prefer the cast     
 *   
 * - DelegateCreationExpressions have been removed from the grammar because they
 *   cannot be syntactically distinguished from an ObjectCreationExpression.
 * -----------------------------------------------------------------------------
 *
 * This file has been modified to connect the C# grammar to the PADL meta-model
 * for the PTIDEJ tool (http://www.yann-gael.gueheneuc.net/Work/Info/).
 *
 * Author: Gerardo Cepeda Porras, Universit� de Montr�al; gerardocepeda@gmail.com
 *
 * Date: April 2009
 */
public class CSharpParser extends Parser implements Constants {
	// delegates
	// delegators

	public CSharpParser(TokenStream input) {
		this(input, new RecognizerSharedState());
	}
	public CSharpParser(TokenStream input, RecognizerSharedState state) {
		super(input, state);
		this.state.ruleMemo = new HashMap[1311 + 1];

	}

	protected TreeAdaptor adaptor = new CommonTreeAdaptor();

	public void setTreeAdaptor(TreeAdaptor adaptor) {
		this.adaptor = adaptor;
	}
	public TreeAdaptor getTreeAdaptor() {
		return this.adaptor;
	}

	public String[] getTokenNames() {
		return Constants.tokenNames;
	}
	public String getGrammarFileName() {
		return "../rsc/CSharp.g3";
	}

	private static ICodeLevelModel codeLevelModel;
	public ICSharpFactory factory;
	public int Classmodifier;
	public int Fieldmodifier;
	public int MethodModifier;
	public Object MethodReturn;
	public char[] Methordreturns;
	public IField element1;
	public IMethod element;
	public Object internalInterface;
	public IParameter param;
	public int InterfaceModifier;
	public boolean methodstock = false;
	private Map tokenNameMap = new HashMap();
	public ArrayList classStockBody = new ArrayList();
	public ArrayList MethodStockBody = new ArrayList();
	public int ElementclassNumber = 0;
	public int ElementMethodNumber = 0;

	public ICSharpFactory getFactory() {
		return this.factory;
	}
	public void setFactory(final ICSharpFactory aFactory) {
		this.factory = aFactory;
	}
	public static ICodeLevelModel getCodeLevelModel() {
		return codeLevelModel;
	}
	public ICodeLevelModel setCodeLevelModel(
		final ICodeLevelModel acodeLevelModel) {
		return CSharpParser.codeLevelModel = acodeLevelModel;
	}

	public static class keyword_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "keyword"
	// ../rsc/CSharp.g3:321:1: keyword : ( aBSTRACT | aS | bASE | bOOL | bREAK | bYTE | cASE | cATCH | cHAR | cHECKED | cLASS | cONST | cONTINUE | dECIMAL | dEFAULT | dELEGATE | dO | dOUBLE | eLSE | eNUM | eVENT | eXPLICIT | eXTERN | fALSE | fINALLY | fIXED | fLOAT | fOR | fOREACH | gOTO | iF | iMPLICIT | iN | iNT | iNTERFACE | iNTERNAL | iS | lOCK | lONG | nAMESPACE | nEW | nULL | oBJECT | oPERATOR | oUT | oVERRIDE | pARAMS | pRIVATE | pROTECTED | pUBLIC | rEADONLY | rEF | rETURN | sBYTE | sEALED | sHORT | sIZEOF | sTACKALLOC | sTATIC | sTRING | sTRUCT | sWITCH | tHIS | tHROW | tRUE | tRY | tYPEOF | uINT | uLONG | uNCHECKED | uNSAFE | uSHORT | uSING | vIRTUAL | vOID | vOLATILE | wHILE );
	public final CSharpParser.keyword_return keyword()
			throws RecognitionException {
		CSharpParser.keyword_return retval = new CSharpParser.keyword_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.aBSTRACT_return aBSTRACT1 = null;

		CSharpParser.aS_return aS2 = null;

		CSharpParser.bASE_return bASE3 = null;

		CSharpParser.bOOL_return bOOL4 = null;

		CSharpParser.bREAK_return bREAK5 = null;

		CSharpParser.bYTE_return bYTE6 = null;

		CSharpParser.cASE_return cASE7 = null;

		CSharpParser.cATCH_return cATCH8 = null;

		CSharpParser.cHAR_return cHAR9 = null;

		CSharpParser.cHECKED_return cHECKED10 = null;

		CSharpParser.cLASS_return cLASS11 = null;

		CSharpParser.cONST_return cONST12 = null;

		CSharpParser.cONTINUE_return cONTINUE13 = null;

		CSharpParser.dECIMAL_return dECIMAL14 = null;

		CSharpParser.dEFAULT_return dEFAULT15 = null;

		CSharpParser.dELEGATE_return dELEGATE16 = null;

		CSharpParser.dO_return dO17 = null;

		CSharpParser.dOUBLE_return dOUBLE18 = null;

		CSharpParser.eLSE_return eLSE19 = null;

		CSharpParser.eNUM_return eNUM20 = null;

		CSharpParser.eVENT_return eVENT21 = null;

		CSharpParser.eXPLICIT_return eXPLICIT22 = null;

		CSharpParser.eXTERN_return eXTERN23 = null;

		CSharpParser.fALSE_return fALSE24 = null;

		CSharpParser.fINALLY_return fINALLY25 = null;

		CSharpParser.fIXED_return fIXED26 = null;

		CSharpParser.fLOAT_return fLOAT27 = null;

		CSharpParser.fOR_return fOR28 = null;

		CSharpParser.fOREACH_return fOREACH29 = null;

		CSharpParser.gOTO_return gOTO30 = null;

		CSharpParser.iF_return iF31 = null;

		CSharpParser.iMPLICIT_return iMPLICIT32 = null;

		CSharpParser.iN_return iN33 = null;

		CSharpParser.iNT_return iNT34 = null;

		CSharpParser.iNTERFACE_return iNTERFACE35 = null;

		CSharpParser.iNTERNAL_return iNTERNAL36 = null;

		CSharpParser.iS_return iS37 = null;

		CSharpParser.lOCK_return lOCK38 = null;

		CSharpParser.lONG_return lONG39 = null;

		CSharpParser.nAMESPACE_return nAMESPACE40 = null;

		CSharpParser.nEW_return nEW41 = null;

		CSharpParser.nULL_return nULL42 = null;

		CSharpParser.oBJECT_return oBJECT43 = null;

		CSharpParser.oPERATOR_return oPERATOR44 = null;

		CSharpParser.oUT_return oUT45 = null;

		CSharpParser.oVERRIDE_return oVERRIDE46 = null;

		CSharpParser.pARAMS_return pARAMS47 = null;

		CSharpParser.pRIVATE_return pRIVATE48 = null;

		CSharpParser.pROTECTED_return pROTECTED49 = null;

		CSharpParser.pUBLIC_return pUBLIC50 = null;

		CSharpParser.rEADONLY_return rEADONLY51 = null;

		CSharpParser.rEF_return rEF52 = null;

		CSharpParser.rETURN_return rETURN53 = null;

		CSharpParser.sBYTE_return sBYTE54 = null;

		CSharpParser.sEALED_return sEALED55 = null;

		CSharpParser.sHORT_return sHORT56 = null;

		CSharpParser.sIZEOF_return sIZEOF57 = null;

		CSharpParser.sTACKALLOC_return sTACKALLOC58 = null;

		CSharpParser.sTATIC_return sTATIC59 = null;

		CSharpParser.sTRING_return sTRING60 = null;

		CSharpParser.sTRUCT_return sTRUCT61 = null;

		CSharpParser.sWITCH_return sWITCH62 = null;

		CSharpParser.tHIS_return tHIS63 = null;

		CSharpParser.tHROW_return tHROW64 = null;

		CSharpParser.tRUE_return tRUE65 = null;

		CSharpParser.tRY_return tRY66 = null;

		CSharpParser.tYPEOF_return tYPEOF67 = null;

		CSharpParser.uINT_return uINT68 = null;

		CSharpParser.uLONG_return uLONG69 = null;

		CSharpParser.uNCHECKED_return uNCHECKED70 = null;

		CSharpParser.uNSAFE_return uNSAFE71 = null;

		CSharpParser.uSHORT_return uSHORT72 = null;

		CSharpParser.uSING_return uSING73 = null;

		CSharpParser.vIRTUAL_return vIRTUAL74 = null;

		CSharpParser.vOID_return vOID75 = null;

		CSharpParser.vOLATILE_return vOLATILE76 = null;

		CSharpParser.wHILE_return wHILE77 = null;

		try {
			// ../rsc/CSharp.g3:322:5: ( aBSTRACT | aS | bASE | bOOL | bREAK | bYTE | cASE | cATCH | cHAR | cHECKED | cLASS | cONST | cONTINUE | dECIMAL | dEFAULT | dELEGATE | dO | dOUBLE | eLSE | eNUM | eVENT | eXPLICIT | eXTERN | fALSE | fINALLY | fIXED | fLOAT | fOR | fOREACH | gOTO | iF | iMPLICIT | iN | iNT | iNTERFACE | iNTERNAL | iS | lOCK | lONG | nAMESPACE | nEW | nULL | oBJECT | oPERATOR | oUT | oVERRIDE | pARAMS | pRIVATE | pROTECTED | pUBLIC | rEADONLY | rEF | rETURN | sBYTE | sEALED | sHORT | sIZEOF | sTACKALLOC | sTATIC | sTRING | sTRUCT | sWITCH | tHIS | tHROW | tRUE | tRY | tYPEOF | uINT | uLONG | uNCHECKED | uNSAFE | uSHORT | uSING | vIRTUAL | vOID | vOLATILE | wHILE )
			int alt1 = 77;
			alt1 = this.dfa1.predict(this.input);
			switch (alt1) {
				case 1 :
				// ../rsc/CSharp.g3:322:10: aBSTRACT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aBSTRACT_in_keyword909);
						aBSTRACT1 = aBSTRACT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aBSTRACT1.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:322:21: aS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aS_in_keyword913);
						aS2 = aS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aS2.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:322:26: bASE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bASE_in_keyword917);
						bASE3 = bASE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bASE3.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:322:33: bOOL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bOOL_in_keyword921);
						bOOL4 = bOOL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bOOL4.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:322:40: bREAK
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bREAK_in_keyword925);
						bREAK5 = bREAK();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bREAK5.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:322:48: bYTE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bYTE_in_keyword929);
						bYTE6 = bYTE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bYTE6.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:322:55: cASE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cASE_in_keyword933);
						cASE7 = cASE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cASE7.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:322:62: cATCH
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cATCH_in_keyword937);
						cATCH8 = cATCH();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cATCH8.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:322:70: cHAR
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cHAR_in_keyword941);
						cHAR9 = cHAR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cHAR9.getTree());

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:322:78: cHECKED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cHECKED_in_keyword946);
						cHECKED10 = cHECKED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cHECKED10.getTree());

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:322:88: cLASS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cLASS_in_keyword950);
						cLASS11 = cLASS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cLASS11.getTree());

					}
					break;
				case 12 :
				// ../rsc/CSharp.g3:322:96: cONST
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cONST_in_keyword954);
						cONST12 = cONST();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cONST12.getTree());

					}
					break;
				case 13 :
				// ../rsc/CSharp.g3:323:10: cONTINUE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cONTINUE_in_keyword965);
						cONTINUE13 = cONTINUE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cONTINUE13.getTree());

					}
					break;
				case 14 :
				// ../rsc/CSharp.g3:323:21: dECIMAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dECIMAL_in_keyword969);
						dECIMAL14 = dECIMAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dECIMAL14.getTree());

					}
					break;
				case 15 :
				// ../rsc/CSharp.g3:323:31: dEFAULT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dEFAULT_in_keyword973);
						dEFAULT15 = dEFAULT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dEFAULT15.getTree());

					}
					break;
				case 16 :
				// ../rsc/CSharp.g3:323:41: dELEGATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dELEGATE_in_keyword977);
						dELEGATE16 = dELEGATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dELEGATE16.getTree());

					}
					break;
				case 17 :
				// ../rsc/CSharp.g3:323:52: dO
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dO_in_keyword981);
						dO17 = dO();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dO17.getTree());

					}
					break;
				case 18 :
				// ../rsc/CSharp.g3:323:57: dOUBLE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dOUBLE_in_keyword985);
						dOUBLE18 = dOUBLE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dOUBLE18.getTree());

					}
					break;
				case 19 :
				// ../rsc/CSharp.g3:323:66: eLSE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eLSE_in_keyword989);
						eLSE19 = eLSE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eLSE19.getTree());

					}
					break;
				case 20 :
				// ../rsc/CSharp.g3:323:73: eNUM
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eNUM_in_keyword993);
						eNUM20 = eNUM();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eNUM20.getTree());

					}
					break;
				case 21 :
				// ../rsc/CSharp.g3:323:80: eVENT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eVENT_in_keyword997);
						eVENT21 = eVENT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eVENT21.getTree());

					}
					break;
				case 22 :
				// ../rsc/CSharp.g3:323:88: eXPLICIT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXPLICIT_in_keyword1001);
						eXPLICIT22 = eXPLICIT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXPLICIT22.getTree());

					}
					break;
				case 23 :
				// ../rsc/CSharp.g3:323:99: eXTERN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXTERN_in_keyword1005);
						eXTERN23 = eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXTERN23.getTree());

					}
					break;
				case 24 :
				// ../rsc/CSharp.g3:324:10: fALSE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fALSE_in_keyword1016);
						fALSE24 = fALSE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fALSE24.getTree());

					}
					break;
				case 25 :
				// ../rsc/CSharp.g3:324:18: fINALLY
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fINALLY_in_keyword1020);
						fINALLY25 = fINALLY();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fINALLY25.getTree());

					}
					break;
				case 26 :
				// ../rsc/CSharp.g3:324:28: fIXED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fIXED_in_keyword1024);
						fIXED26 = fIXED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fIXED26.getTree());

					}
					break;
				case 27 :
				// ../rsc/CSharp.g3:324:36: fLOAT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fLOAT_in_keyword1028);
						fLOAT27 = fLOAT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fLOAT27.getTree());

					}
					break;
				case 28 :
				// ../rsc/CSharp.g3:324:44: fOR
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fOR_in_keyword1032);
						fOR28 = fOR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fOR28.getTree());

					}
					break;
				case 29 :
				// ../rsc/CSharp.g3:324:50: fOREACH
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fOREACH_in_keyword1036);
						fOREACH29 = fOREACH();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fOREACH29.getTree());

					}
					break;
				case 30 :
				// ../rsc/CSharp.g3:324:60: gOTO
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_gOTO_in_keyword1040);
						gOTO30 = gOTO();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, gOTO30.getTree());

					}
					break;
				case 31 :
				// ../rsc/CSharp.g3:324:67: iF
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iF_in_keyword1044);
						iF31 = iF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iF31.getTree());

					}
					break;
				case 32 :
				// ../rsc/CSharp.g3:324:72: iMPLICIT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iMPLICIT_in_keyword1048);
						iMPLICIT32 = iMPLICIT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iMPLICIT32.getTree());

					}
					break;
				case 33 :
				// ../rsc/CSharp.g3:324:83: iN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iN_in_keyword1052);
						iN33 = iN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iN33.getTree());

					}
					break;
				case 34 :
				// ../rsc/CSharp.g3:324:88: iNT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNT_in_keyword1056);
						iNT34 = iNT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNT34.getTree());

					}
					break;
				case 35 :
				// ../rsc/CSharp.g3:324:94: iNTERFACE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERFACE_in_keyword1060);
						iNTERFACE35 = iNTERFACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERFACE35.getTree());

					}
					break;
				case 36 :
				// ../rsc/CSharp.g3:325:10: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_keyword1071);
						iNTERNAL36 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL36.getTree());

					}
					break;
				case 37 :
				// ../rsc/CSharp.g3:325:21: iS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iS_in_keyword1075);
						iS37 = iS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iS37.getTree());

					}
					break;
				case 38 :
				// ../rsc/CSharp.g3:325:26: lOCK
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lOCK_in_keyword1079);
						lOCK38 = lOCK();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, lOCK38.getTree());

					}
					break;
				case 39 :
				// ../rsc/CSharp.g3:325:33: lONG
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lONG_in_keyword1083);
						lONG39 = lONG();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, lONG39.getTree());

					}
					break;
				case 40 :
				// ../rsc/CSharp.g3:325:40: nAMESPACE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nAMESPACE_in_keyword1087);
						nAMESPACE40 = nAMESPACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nAMESPACE40.getTree());

					}
					break;
				case 41 :
				// ../rsc/CSharp.g3:325:52: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_keyword1091);
						nEW41 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW41.getTree());

					}
					break;
				case 42 :
				// ../rsc/CSharp.g3:325:58: nULL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nULL_in_keyword1095);
						nULL42 = nULL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nULL42.getTree());

					}
					break;
				case 43 :
				// ../rsc/CSharp.g3:325:65: oBJECT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oBJECT_in_keyword1099);
						oBJECT43 = oBJECT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oBJECT43.getTree());

					}
					break;
				case 44 :
				// ../rsc/CSharp.g3:325:74: oPERATOR
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oPERATOR_in_keyword1103);
						oPERATOR44 = oPERATOR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oPERATOR44.getTree());

					}
					break;
				case 45 :
				// ../rsc/CSharp.g3:325:85: oUT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oUT_in_keyword1107);
						oUT45 = oUT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oUT45.getTree());

					}
					break;
				case 46 :
				// ../rsc/CSharp.g3:325:91: oVERRIDE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oVERRIDE_in_keyword1111);
						oVERRIDE46 = oVERRIDE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oVERRIDE46.getTree());

					}
					break;
				case 47 :
				// ../rsc/CSharp.g3:326:10: pARAMS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pARAMS_in_keyword1122);
						pARAMS47 = pARAMS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pARAMS47.getTree());

					}
					break;
				case 48 :
				// ../rsc/CSharp.g3:326:19: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_keyword1126);
						pRIVATE48 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE48.getTree());

					}
					break;
				case 49 :
				// ../rsc/CSharp.g3:326:29: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_keyword1130);
						pROTECTED49 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED49.getTree());

					}
					break;
				case 50 :
				// ../rsc/CSharp.g3:326:42: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_keyword1135);
						pUBLIC50 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC50.getTree());

					}
					break;
				case 51 :
				// ../rsc/CSharp.g3:326:51: rEADONLY
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_rEADONLY_in_keyword1139);
						rEADONLY51 = rEADONLY();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, rEADONLY51.getTree());

					}
					break;
				case 52 :
				// ../rsc/CSharp.g3:326:62: rEF
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_rEF_in_keyword1143);
						rEF52 = rEF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, rEF52.getTree());

					}
					break;
				case 53 :
				// ../rsc/CSharp.g3:326:68: rETURN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_rETURN_in_keyword1147);
						rETURN53 = rETURN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, rETURN53.getTree());

					}
					break;
				case 54 :
				// ../rsc/CSharp.g3:326:77: sBYTE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sBYTE_in_keyword1151);
						sBYTE54 = sBYTE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sBYTE54.getTree());

					}
					break;
				case 55 :
				// ../rsc/CSharp.g3:326:85: sEALED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEALED_in_keyword1155);
						sEALED55 = sEALED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEALED55.getTree());

					}
					break;
				case 56 :
				// ../rsc/CSharp.g3:326:94: sHORT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sHORT_in_keyword1159);
						sHORT56 = sHORT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sHORT56.getTree());

					}
					break;
				case 57 :
				// ../rsc/CSharp.g3:327:10: sIZEOF
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sIZEOF_in_keyword1170);
						sIZEOF57 = sIZEOF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sIZEOF57.getTree());

					}
					break;
				case 58 :
				// ../rsc/CSharp.g3:327:19: sTACKALLOC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTACKALLOC_in_keyword1174);
						sTACKALLOC58 = sTACKALLOC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTACKALLOC58.getTree());

					}
					break;
				case 59 :
				// ../rsc/CSharp.g3:327:32: sTATIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTATIC_in_keyword1178);
						sTATIC59 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTATIC59.getTree());

					}
					break;
				case 60 :
				// ../rsc/CSharp.g3:327:41: sTRING
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTRING_in_keyword1182);
						sTRING60 = sTRING();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTRING60.getTree());

					}
					break;
				case 61 :
				// ../rsc/CSharp.g3:327:50: sTRUCT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTRUCT_in_keyword1186);
						sTRUCT61 = sTRUCT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTRUCT61.getTree());

					}
					break;
				case 62 :
				// ../rsc/CSharp.g3:327:59: sWITCH
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sWITCH_in_keyword1190);
						sWITCH62 = sWITCH();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sWITCH62.getTree());

					}
					break;
				case 63 :
				// ../rsc/CSharp.g3:327:68: tHIS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tHIS_in_keyword1194);
						tHIS63 = tHIS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tHIS63.getTree());

					}
					break;
				case 64 :
				// ../rsc/CSharp.g3:327:75: tHROW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tHROW_in_keyword1198);
						tHROW64 = tHROW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tHROW64.getTree());

					}
					break;
				case 65 :
				// ../rsc/CSharp.g3:327:83: tRUE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tRUE_in_keyword1202);
						tRUE65 = tRUE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tRUE65.getTree());

					}
					break;
				case 66 :
				// ../rsc/CSharp.g3:327:90: tRY
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tRY_in_keyword1206);
						tRY66 = tRY();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tRY66.getTree());

					}
					break;
				case 67 :
				// ../rsc/CSharp.g3:327:96: tYPEOF
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tYPEOF_in_keyword1210);
						tYPEOF67 = tYPEOF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tYPEOF67.getTree());

					}
					break;
				case 68 :
				// ../rsc/CSharp.g3:328:10: uINT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uINT_in_keyword1221);
						uINT68 = uINT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uINT68.getTree());

					}
					break;
				case 69 :
				// ../rsc/CSharp.g3:328:17: uLONG
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uLONG_in_keyword1225);
						uLONG69 = uLONG();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uLONG69.getTree());

					}
					break;
				case 70 :
				// ../rsc/CSharp.g3:328:25: uNCHECKED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uNCHECKED_in_keyword1229);
						uNCHECKED70 = uNCHECKED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uNCHECKED70.getTree());

					}
					break;
				case 71 :
				// ../rsc/CSharp.g3:328:37: uNSAFE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uNSAFE_in_keyword1233);
						uNSAFE71 = uNSAFE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uNSAFE71.getTree());

					}
					break;
				case 72 :
				// ../rsc/CSharp.g3:328:46: uSHORT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uSHORT_in_keyword1237);
						uSHORT72 = uSHORT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uSHORT72.getTree());

					}
					break;
				case 73 :
				// ../rsc/CSharp.g3:328:55: uSING
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uSING_in_keyword1241);
						uSING73 = uSING();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uSING73.getTree());

					}
					break;
				case 74 :
				// ../rsc/CSharp.g3:328:63: vIRTUAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vIRTUAL_in_keyword1245);
						vIRTUAL74 = vIRTUAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vIRTUAL74.getTree());

					}
					break;
				case 75 :
				// ../rsc/CSharp.g3:328:73: vOID
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vOID_in_keyword1249);
						vOID75 = vOID();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vOID75.getTree());

					}
					break;
				case 76 :
				// ../rsc/CSharp.g3:328:80: vOLATILE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vOLATILE_in_keyword1253);
						vOLATILE76 = vOLATILE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vOLATILE76.getTree());

					}
					break;
				case 77 :
				// ../rsc/CSharp.g3:328:91: wHILE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_wHILE_in_keyword1257);
						wHILE77 = wHILE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, wHILE77.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "keyword"

	public static class identifier_return extends ParserRuleReturnScope {
		public String content;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "identifier"
	// ../rsc/CSharp.g3:332:1: identifier returns [String content] : ( ident -> Identifier[$ident.start] | aDD -> Identifier[$aDD.start] | aLIAS -> Identifier[$aLIAS.start] | gET -> Identifier[$gET.start] | pARTIAL -> Identifier[$pARTIAL.start] | rEMOVE -> Identifier[$rEMOVE.start] | sET -> Identifier[$sET.start] | wHERE -> Identifier[$wHERE.start] | yIELD -> Identifier[$yIELD.start] );
	public final CSharpParser.identifier_return identifier()
			throws RecognitionException {
		CSharpParser.identifier_return retval =
			new CSharpParser.identifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.ident_return ident78 = null;

		CSharpParser.aDD_return aDD79 = null;

		CSharpParser.aLIAS_return aLIAS80 = null;

		CSharpParser.gET_return gET81 = null;

		CSharpParser.pARTIAL_return pARTIAL82 = null;

		CSharpParser.rEMOVE_return rEMOVE83 = null;

		CSharpParser.sET_return sET84 = null;

		CSharpParser.wHERE_return wHERE85 = null;

		CSharpParser.yIELD_return yIELD86 = null;

		RewriteRuleSubtreeStream stream_pARTIAL =
			new RewriteRuleSubtreeStream(this.adaptor, "rule pARTIAL");
		RewriteRuleSubtreeStream stream_aDD =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aDD");
		RewriteRuleSubtreeStream stream_ident =
			new RewriteRuleSubtreeStream(this.adaptor, "rule ident");
		RewriteRuleSubtreeStream stream_aLIAS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aLIAS");
		RewriteRuleSubtreeStream stream_yIELD =
			new RewriteRuleSubtreeStream(this.adaptor, "rule yIELD");
		RewriteRuleSubtreeStream stream_wHERE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule wHERE");
		RewriteRuleSubtreeStream stream_gET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gET");
		RewriteRuleSubtreeStream stream_rEMOVE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rEMOVE");
		RewriteRuleSubtreeStream stream_sET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sET");
		try {
			// ../rsc/CSharp.g3:333:2: ( ident -> Identifier[$ident.start] | aDD -> Identifier[$aDD.start] | aLIAS -> Identifier[$aLIAS.start] | gET -> Identifier[$gET.start] | pARTIAL -> Identifier[$pARTIAL.start] | rEMOVE -> Identifier[$rEMOVE.start] | sET -> Identifier[$sET.start] | wHERE -> Identifier[$wHERE.start] | yIELD -> Identifier[$yIELD.start] )
			int alt2 = 9;
			alt2 = this.dfa2.predict(this.input);
			switch (alt2) {
				case 1 :
				// ../rsc/CSharp.g3:333:4: ident
					{
						pushFollow(FOLLOW_ident_in_identifier1276);
						ident78 = ident();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_ident.add(ident78.getTree());
						if (this.state.backtracking == 0) {
							retval.content =
								(ident78 != null ? ((Token) ident78.start)
										: null).getText();
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 334:2: -> Identifier[$ident.start]
							{
								this.adaptor
									.addChild(
										root_0,
										(Object) this.adaptor
											.create(
												Identifier,
												(ident78 != null ? ((Token) ident78.start)
														: null)));

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:335:4: aDD
					{
						pushFollow(FOLLOW_aDD_in_identifier1289);
						aDD79 = aDD();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_aDD.add(aDD79.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "add";
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 336:2: -> Identifier[$aDD.start]
							{
								this.adaptor.addChild(root_0, (Object) this.adaptor
									.create(
										Identifier,
										(aDD79 != null ? ((Token) aDD79.start)
												: null)));

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:337:5: aLIAS
					{
						pushFollow(FOLLOW_aLIAS_in_identifier1303);
						aLIAS80 = aLIAS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_aLIAS.add(aLIAS80.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "alias";
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 338:2: -> Identifier[$aLIAS.start]
							{
								this.adaptor
									.addChild(
										root_0,
										(Object) this.adaptor
											.create(
												Identifier,
												(aLIAS80 != null ? ((Token) aLIAS80.start)
														: null)));

							}

							retval.tree = root_0;
						}
					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:339:5: gET
					{
						pushFollow(FOLLOW_gET_in_identifier1317);
						gET81 = gET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_gET.add(gET81.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "get";
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 340:2: -> Identifier[$gET.start]
							{
								this.adaptor.addChild(root_0, (Object) this.adaptor
									.create(
										Identifier,
										(gET81 != null ? ((Token) gET81.start)
												: null)));

							}

							retval.tree = root_0;
						}
					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:341:5: pARTIAL
					{
						pushFollow(FOLLOW_pARTIAL_in_identifier1331);
						pARTIAL82 = pARTIAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_pARTIAL.add(pARTIAL82.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "partial";
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 342:2: -> Identifier[$pARTIAL.start]
							{
								this.adaptor
									.addChild(
										root_0,
										(Object) this.adaptor
											.create(
												Identifier,
												(pARTIAL82 != null ? ((Token) pARTIAL82.start)
														: null)));

							}

							retval.tree = root_0;
						}
					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:343:5: rEMOVE
					{
						pushFollow(FOLLOW_rEMOVE_in_identifier1345);
						rEMOVE83 = rEMOVE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rEMOVE.add(rEMOVE83.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "remove";
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 344:2: -> Identifier[$rEMOVE.start]
							{
								this.adaptor
									.addChild(
										root_0,
										(Object) this.adaptor
											.create(
												Identifier,
												(rEMOVE83 != null ? ((Token) rEMOVE83.start)
														: null)));

							}

							retval.tree = root_0;
						}
					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:345:5: sET
					{
						pushFollow(FOLLOW_sET_in_identifier1359);
						sET84 = sET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sET.add(sET84.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "set";
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 346:2: -> Identifier[$sET.start]
							{
								this.adaptor.addChild(root_0, (Object) this.adaptor
									.create(
										Identifier,
										(sET84 != null ? ((Token) sET84.start)
												: null)));

							}

							retval.tree = root_0;
						}
					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:347:5: wHERE
					{
						pushFollow(FOLLOW_wHERE_in_identifier1373);
						wHERE85 = wHERE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_wHERE.add(wHERE85.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "where";
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 348:2: -> Identifier[$wHERE.start]
							{
								this.adaptor
									.addChild(
										root_0,
										(Object) this.adaptor
											.create(
												Identifier,
												(wHERE85 != null ? ((Token) wHERE85.start)
														: null)));

							}

							retval.tree = root_0;
						}
					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:349:5: yIELD
					{
						pushFollow(FOLLOW_yIELD_in_identifier1387);
						yIELD86 = yIELD();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_yIELD.add(yIELD86.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "yield";
						}

						// AST REWRITE
						// elements: 
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 350:2: -> Identifier[$yIELD.start]
							{
								this.adaptor
									.addChild(
										root_0,
										(Object) this.adaptor
											.create(
												Identifier,
												(yIELD86 != null ? ((Token) yIELD86.start)
														: null)));

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "identifier"

	public static class compilationunit_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "compilationunit"
	// ../rsc/CSharp.g3:357:1: compilationunit : ( ignoredtail )? ( externaliasdirectives )? ( usingdirectives )? ( globalattributes )? ( namespacememberdeclarations )? EOF -> ^( CompilationUnit ( externaliasdirectives )? ( usingdirectives )? ( globalattributes )? ( namespacememberdeclarations )? ) ;
	public final CSharpParser.compilationunit_return compilationunit()
			throws RecognitionException {
		CSharpParser.compilationunit_return retval =
			new CSharpParser.compilationunit_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token EOF92 = null;
		CSharpParser.ignoredtail_return ignoredtail87 = null;

		CSharpParser.externaliasdirectives_return externaliasdirectives88 =
			null;

		CSharpParser.usingdirectives_return usingdirectives89 = null;

		CSharpParser.globalattributes_return globalattributes90 = null;

		CSharpParser.namespacememberdeclarations_return namespacememberdeclarations91 =
			null;

		RewriteRuleTokenStream stream_EOF =
			new RewriteRuleTokenStream(this.adaptor, "token EOF");
		RewriteRuleSubtreeStream stream_globalattributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule globalattributes");
		RewriteRuleSubtreeStream stream_externaliasdirectives =
			new RewriteRuleSubtreeStream(this.adaptor, "rule externaliasdirectives");
		RewriteRuleSubtreeStream stream_namespacememberdeclarations =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule namespacememberdeclarations");
		RewriteRuleSubtreeStream stream_ignoredtail =
			new RewriteRuleSubtreeStream(this.adaptor, "rule ignoredtail");
		RewriteRuleSubtreeStream stream_usingdirectives =
			new RewriteRuleSubtreeStream(this.adaptor, "rule usingdirectives");
		try {
			// ../rsc/CSharp.g3:366:5: ( ( ignoredtail )? ( externaliasdirectives )? ( usingdirectives )? ( globalattributes )? ( namespacememberdeclarations )? EOF -> ^( CompilationUnit ( externaliasdirectives )? ( usingdirectives )? ( globalattributes )? ( namespacememberdeclarations )? ) )
			// ../rsc/CSharp.g3:366:9: ( ignoredtail )? ( externaliasdirectives )? ( usingdirectives )? ( globalattributes )? ( namespacememberdeclarations )? EOF
			{
				// ../rsc/CSharp.g3:366:9: ( ignoredtail )?
				int alt3 = 2;
				int LA3_0 = this.input.LA(1);

				if (((LA3_0 >= Whitespace && LA3_0 <= Preprocessordirective))) {
					alt3 = 1;
				}
				switch (alt3) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_compilationunit1420);
							ignoredtail87 = ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_ignoredtail.add(ignoredtail87.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:366:22: ( externaliasdirectives )?
				int alt4 = 2;
				int LA4_0 = this.input.LA(1);

				if ((LA4_0 == EXTERN)) {
					alt4 = 1;
				}
				switch (alt4) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: externaliasdirectives
						{
							pushFollow(FOLLOW_externaliasdirectives_in_compilationunit1423);
							externaliasdirectives88 = externaliasdirectives();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_externaliasdirectives
									.add(externaliasdirectives88.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:366:45: ( usingdirectives )?
				int alt5 = 2;
				int LA5_0 = this.input.LA(1);

				if ((LA5_0 == USING)) {
					alt5 = 1;
				}
				switch (alt5) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: usingdirectives
						{
							pushFollow(FOLLOW_usingdirectives_in_compilationunit1426);
							usingdirectives89 = usingdirectives();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_usingdirectives.add(usingdirectives89
									.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:366:62: ( globalattributes )?
				int alt6 = 2;
				alt6 = this.dfa6.predict(this.input);
				switch (alt6) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: globalattributes
						{
							pushFollow(FOLLOW_globalattributes_in_compilationunit1429);
							globalattributes90 = globalattributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_globalattributes.add(globalattributes90
									.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:366:80: ( namespacememberdeclarations )?
				int alt7 = 2;
				int LA7_0 = this.input.LA(1);

				if ((LA7_0 == LBRACKET || LA7_0 == ABSTRACT || LA7_0 == CLASS
						|| LA7_0 == DELEGATE || LA7_0 == ENUM
						|| (LA7_0 >= INTERFACE && LA7_0 <= INTERNAL)
						|| (LA7_0 >= NAMESPACE && LA7_0 <= NEW)
						|| (LA7_0 >= PRIVATE && LA7_0 <= PUBLIC)
						|| LA7_0 == SEALED || LA7_0 == STATIC
						|| LA7_0 == STRUCT || LA7_0 == PARTIAL)) {
					alt7 = 1;
				}
				switch (alt7) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: namespacememberdeclarations
						{
							pushFollow(FOLLOW_namespacememberdeclarations_in_compilationunit1432);
							namespacememberdeclarations91 =
								namespacememberdeclarations();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_namespacememberdeclarations
									.add(namespacememberdeclarations91
										.getTree());

						}
						break;

				}

				EOF92 =
					(Token) match(this.input, EOF, FOLLOW_EOF_in_compilationunit1435);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_EOF.add(EOF92);

				// AST REWRITE
				// elements: namespacememberdeclarations, globalattributes, externaliasdirectives, usingdirectives
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 367:5: -> ^( CompilationUnit ( externaliasdirectives )? ( usingdirectives )? ( globalattributes )? ( namespacememberdeclarations )? )
					{
						// ../rsc/CSharp.g3:367:8: ^( CompilationUnit ( externaliasdirectives )? ( usingdirectives )? ( globalattributes )? ( namespacememberdeclarations )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										CompilationUnit,
										"CompilationUnit"),
									root_1);

							// ../rsc/CSharp.g3:367:26: ( externaliasdirectives )?
							if (stream_externaliasdirectives.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_externaliasdirectives.nextTree());

							}
							stream_externaliasdirectives.reset();
							// ../rsc/CSharp.g3:367:49: ( usingdirectives )?
							if (stream_usingdirectives.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_usingdirectives.nextTree());

							}
							stream_usingdirectives.reset();
							// ../rsc/CSharp.g3:367:66: ( globalattributes )?
							if (stream_globalattributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_globalattributes.nextTree());

							}
							stream_globalattributes.reset();
							// ../rsc/CSharp.g3:367:84: ( namespacememberdeclarations )?
							if (stream_namespacememberdeclarations.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_namespacememberdeclarations
										.nextTree());

							}
							stream_namespacememberdeclarations.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "compilationunit"

	public static class namespacename_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "namespacename"
	// ../rsc/CSharp.g3:371:1: namespacename : namespaceortypename -> ^( NamespaceName namespaceortypename ) ;
	public final CSharpParser.namespacename_return namespacename()
			throws RecognitionException {
		CSharpParser.namespacename_return retval =
			new CSharpParser.namespacename_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.namespaceortypename_return namespaceortypename93 = null;

		RewriteRuleSubtreeStream stream_namespaceortypename =
			new RewriteRuleSubtreeStream(this.adaptor, "rule namespaceortypename");
		try {
			// ../rsc/CSharp.g3:372:5: ( namespaceortypename -> ^( NamespaceName namespaceortypename ) )
			// ../rsc/CSharp.g3:372:9: namespaceortypename
			{
				pushFollow(FOLLOW_namespaceortypename_in_namespacename1477);
				namespaceortypename93 = namespaceortypename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_namespaceortypename.add(namespaceortypename93
						.getTree());

				// AST REWRITE
				// elements: namespaceortypename
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 373:5: -> ^( NamespaceName namespaceortypename )
					{
						// ../rsc/CSharp.g3:373:8: ^( NamespaceName namespaceortypename )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										NamespaceName,
										"NamespaceName"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_namespaceortypename.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "namespacename"

	public static class typename_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typename"
	// ../rsc/CSharp.g3:376:1: typename returns [String name] : namespaceortypename -> ^( TypeName namespaceortypename ) ;
	public final CSharpParser.typename_return typename()
			throws RecognitionException {
		CSharpParser.typename_return retval =
			new CSharpParser.typename_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.namespaceortypename_return namespaceortypename94 = null;

		RewriteRuleSubtreeStream stream_namespaceortypename =
			new RewriteRuleSubtreeStream(this.adaptor, "rule namespaceortypename");
		try {
			// ../rsc/CSharp.g3:377:5: ( namespaceortypename -> ^( TypeName namespaceortypename ) )
			// ../rsc/CSharp.g3:377:9: namespaceortypename
			{
				pushFollow(FOLLOW_namespaceortypename_in_typename1512);
				namespaceortypename94 = namespaceortypename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_namespaceortypename.add(namespaceortypename94
						.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(namespaceortypename94 != null ? namespaceortypename94.name
								: null);
				}

				// AST REWRITE
				// elements: namespaceortypename
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 379:5: -> ^( TypeName namespaceortypename )
					{
						// ../rsc/CSharp.g3:379:8: ^( TypeName namespaceortypename )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(TypeName, "TypeName"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_namespaceortypename.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typename"

	public static class namespaceortypename_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "namespaceortypename"
	// ../rsc/CSharp.g3:387:1: namespaceortypename returns [String name] : ( ( simplenamespaceortypename dOT )+ identifier ( typeargumentlist )? | simplenamespaceortypename );
	public final CSharpParser.namespaceortypename_return namespaceortypename()
			throws RecognitionException {
		CSharpParser.namespaceortypename_return retval =
			new CSharpParser.namespaceortypename_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.simplenamespaceortypename_return simplenamespaceortypename95 =
			null;

		CSharpParser.dOT_return dOT96 = null;

		CSharpParser.identifier_return identifier97 = null;

		CSharpParser.typeargumentlist_return typeargumentlist98 = null;

		CSharpParser.simplenamespaceortypename_return simplenamespaceortypename99 =
			null;

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:391:2: ( ( simplenamespaceortypename dOT )+ identifier ( typeargumentlist )? | simplenamespaceortypename )
			int alt10 = 2;
			alt10 = this.dfa10.predict(this.input);
			switch (alt10) {
				case 1 :
				// ../rsc/CSharp.g3:391:4: ( simplenamespaceortypename dOT )+ identifier ( typeargumentlist )?
					{
						root_0 = (Object) this.adaptor.nil();

						// ../rsc/CSharp.g3:391:4: ( simplenamespaceortypename dOT )+
						int cnt8 = 0;
						loop8: do {
							int alt8 = 2;
							alt8 = this.dfa8.predict(this.input);
							switch (alt8) {
								case 1 :
								// ../rsc/CSharp.g3:391:5: simplenamespaceortypename dOT
									{
										pushFollow(FOLLOW_simplenamespaceortypename_in_namespaceortypename1560);
										simplenamespaceortypename95 =
											simplenamespaceortypename();

										this.state._fsp--;
										if (this.state.failed)
											return retval;
										if (this.state.backtracking == 0)
											this.adaptor.addChild(
												root_0,
												simplenamespaceortypename95
													.getTree());
										pushFollow(FOLLOW_dOT_in_namespaceortypename1562);
										dOT96 = dOT();

										this.state._fsp--;
										if (this.state.failed)
											return retval;
										if (this.state.backtracking == 0)
											this.adaptor.addChild(
												root_0,
												dOT96.getTree());
										if (this.state.backtracking == 0) {
											sb
												.append(
													(simplenamespaceortypename95 != null ? simplenamespaceortypename95.name
															: null))
												.append('.');
										}

									}
									break;

								default :
									if (cnt8 >= 1)
										break loop8;
									if (this.state.backtracking > 0) {
										this.state.failed = true;
										return retval;
									}
									EarlyExitException eee =
										new EarlyExitException(8, this.input);
									throw eee;
							}
							cnt8++;
						}
						while (true);

						pushFollow(FOLLOW_identifier_in_namespaceortypename1570);
						identifier97 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, identifier97.getTree());
						// ../rsc/CSharp.g3:392:14: ( typeargumentlist )?
						int alt9 = 2;
						alt9 = this.dfa9.predict(this.input);
						switch (alt9) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: typeargumentlist
								{
									pushFollow(FOLLOW_typeargumentlist_in_namespaceortypename1572);
									typeargumentlist98 = typeargumentlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										this.adaptor.addChild(
											root_0,
											typeargumentlist98.getTree());

								}
								break;

						}

						if (this.state.backtracking == 0) {
							sb
								.append((identifier97 != null ? identifier97.content
										: null));
							retval.name = sb.toString();
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:393:4: simplenamespaceortypename
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_simplenamespaceortypename_in_namespaceortypename1580);
						simplenamespaceortypename99 =
							simplenamespaceortypename();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								simplenamespaceortypename99.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(simplenamespaceortypename99 != null ? simplenamespaceortypename99.name
										: null);
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "namespaceortypename"

	public static class simplenamespaceortypename_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "simplenamespaceortypename"
	// ../rsc/CSharp.g3:397:1: simplenamespaceortypename returns [String name] : ( identifier ( typeargumentlist )? | qualifiedaliasmember );
	public final CSharpParser.simplenamespaceortypename_return simplenamespaceortypename()
			throws RecognitionException {
		CSharpParser.simplenamespaceortypename_return retval =
			new CSharpParser.simplenamespaceortypename_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier100 = null;

		CSharpParser.typeargumentlist_return typeargumentlist101 = null;

		CSharpParser.qualifiedaliasmember_return qualifiedaliasmember102 = null;

		try {
			// ../rsc/CSharp.g3:398:2: ( identifier ( typeargumentlist )? | qualifiedaliasmember )
			int alt12 = 2;
			alt12 = this.dfa12.predict(this.input);
			switch (alt12) {
				case 1 :
				// ../rsc/CSharp.g3:398:4: identifier ( typeargumentlist )?
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_identifier_in_simplenamespaceortypename1598);
						identifier100 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, identifier100.getTree());
						// ../rsc/CSharp.g3:398:15: ( typeargumentlist )?
						int alt11 = 2;
						alt11 = this.dfa11.predict(this.input);
						switch (alt11) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: typeargumentlist
								{
									pushFollow(FOLLOW_typeargumentlist_in_simplenamespaceortypename1600);
									typeargumentlist101 = typeargumentlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										this.adaptor.addChild(
											root_0,
											typeargumentlist101.getTree());

								}
								break;

						}

						if (this.state.backtracking == 0) {
							retval.name =
								(identifier100 != null ? identifier100.content
										: null);
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:400:4: qualifiedaliasmember
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_qualifiedaliasmember_in_simplenamespaceortypename1610);
						qualifiedaliasmember102 = qualifiedaliasmember();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								qualifiedaliasmember102.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(qualifiedaliasmember102 != null ? qualifiedaliasmember102.name
										: null);
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "simplenamespaceortypename"

	public static class type_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "type"
	// ../rsc/CSharp.g3:406:1: type returns [String name] : ( referencetype -> ^( Type referencetype ) | valuetype -> ^( Type valuetype ) | typeparameter -> ^( Type typeparameter ) );
	public final CSharpParser.type_return type() throws RecognitionException {
		CSharpParser.type_return retval = new CSharpParser.type_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.referencetype_return referencetype103 = null;

		CSharpParser.valuetype_return valuetype104 = null;

		CSharpParser.typeparameter_return typeparameter105 = null;

		RewriteRuleSubtreeStream stream_valuetype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule valuetype");
		RewriteRuleSubtreeStream stream_referencetype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule referencetype");
		RewriteRuleSubtreeStream stream_typeparameter =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameter");
		try {
			// ../rsc/CSharp.g3:407:5: ( referencetype -> ^( Type referencetype ) | valuetype -> ^( Type valuetype ) | typeparameter -> ^( Type typeparameter ) )
			int alt13 = 3;
			alt13 = this.dfa13.predict(this.input);
			switch (alt13) {
				case 1 :
				// ../rsc/CSharp.g3:407:9: referencetype
					{
						pushFollow(FOLLOW_referencetype_in_type1636);
						referencetype103 = referencetype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_referencetype
								.add(referencetype103.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(referencetype103 != null ? referencetype103.name
										: null);
						}

						// AST REWRITE
						// elements: referencetype
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 409:5: -> ^( Type referencetype )
							{
								// ../rsc/CSharp.g3:409:8: ^( Type referencetype )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Type,
												"Type"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_referencetype.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:410:7: valuetype
					{
						pushFollow(FOLLOW_valuetype_in_type1670);
						valuetype104 = valuetype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_valuetype.add(valuetype104.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(valuetype104 != null ? valuetype104.name
										: null);
						}

						// AST REWRITE
						// elements: valuetype
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 412:5: -> ^( Type valuetype )
							{
								// ../rsc/CSharp.g3:412:8: ^( Type valuetype )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Type,
												"Type"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_valuetype.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:413:9: typeparameter
					{
						pushFollow(FOLLOW_typeparameter_in_type1699);
						typeparameter105 = typeparameter();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_typeparameter
								.add(typeparameter105.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(typeparameter105 != null ? typeparameter105.name
										: null);
						}

						// AST REWRITE
						// elements: typeparameter
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 415:5: -> ^( Type typeparameter )
							{
								// ../rsc/CSharp.g3:415:8: ^( Type typeparameter )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Type,
												"Type"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_typeparameter.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "type"

	public static class valuetype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "valuetype"
	// ../rsc/CSharp.g3:418:1: valuetype returns [String name] : ( structtype | enumtype );
	public final CSharpParser.valuetype_return valuetype()
			throws RecognitionException {
		CSharpParser.valuetype_return retval =
			new CSharpParser.valuetype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.structtype_return structtype106 = null;

		CSharpParser.enumtype_return enumtype107 = null;

		try {
			// ../rsc/CSharp.g3:419:5: ( structtype | enumtype )
			int alt14 = 2;
			alt14 = this.dfa14.predict(this.input);
			switch (alt14) {
				case 1 :
				// ../rsc/CSharp.g3:419:9: structtype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_structtype_in_valuetype1741);
						structtype106 = structtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, structtype106.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(structtype106 != null ? structtype106.name
										: null);
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:421:9: enumtype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_enumtype_in_valuetype1758);
						enumtype107 = enumtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, enumtype107.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(enumtype107 != null ? enumtype107.name : null);
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "valuetype"

	public static class structtype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "structtype"
	// ../rsc/CSharp.g3:425:1: structtype returns [String name] : ( nullabletype | typename | simpletype );
	public final CSharpParser.structtype_return structtype()
			throws RecognitionException {
		CSharpParser.structtype_return retval =
			new CSharpParser.structtype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nullabletype_return nullabletype108 = null;

		CSharpParser.typename_return typename109 = null;

		CSharpParser.simpletype_return simpletype110 = null;

		try {
			// ../rsc/CSharp.g3:426:5: ( nullabletype | typename | simpletype )
			int alt15 = 3;
			alt15 = this.dfa15.predict(this.input);
			switch (alt15) {
				case 1 :
				// ../rsc/CSharp.g3:426:9: nullabletype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nullabletype_in_structtype1788);
						nullabletype108 = nullabletype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nullabletype108.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(nullabletype108 != null ? nullabletype108.name
										: null);
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:428:7: typename
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_typename_in_structtype1809);
						typename109 = typename();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, typename109.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(typename109 != null ? typename109.name : null);
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:430:9: simpletype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_simpletype_in_structtype1826);
						simpletype110 = simpletype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, simpletype110.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(simpletype110 != null ? simpletype110.name
										: null);
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "structtype"

	public static class simpletype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "simpletype"
	// ../rsc/CSharp.g3:434:1: simpletype returns [String name] : ( numerictype -> ^( SimpleType numerictype ) | bOOL -> ^( SimpleType bOOL ) );
	public final CSharpParser.simpletype_return simpletype()
			throws RecognitionException {
		CSharpParser.simpletype_return retval =
			new CSharpParser.simpletype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.numerictype_return numerictype111 = null;

		CSharpParser.bOOL_return bOOL112 = null;

		RewriteRuleSubtreeStream stream_numerictype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule numerictype");
		RewriteRuleSubtreeStream stream_bOOL =
			new RewriteRuleSubtreeStream(this.adaptor, "rule bOOL");
		try {
			// ../rsc/CSharp.g3:435:5: ( numerictype -> ^( SimpleType numerictype ) | bOOL -> ^( SimpleType bOOL ) )
			int alt16 = 2;
			int LA16_0 = this.input.LA(1);

			if ((LA16_0 == BYTE || LA16_0 == CHAR || LA16_0 == DECIMAL
					|| LA16_0 == DOUBLE || LA16_0 == FLOAT || LA16_0 == INT
					|| LA16_0 == LONG || LA16_0 == SBYTE || LA16_0 == SHORT
					|| (LA16_0 >= UINT && LA16_0 <= ULONG) || LA16_0 == USHORT)) {
				alt16 = 1;
			}
			else if ((LA16_0 == BOOL)) {
				alt16 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 16, 0, this.input);

				throw nvae;
			}
			switch (alt16) {
				case 1 :
				// ../rsc/CSharp.g3:435:9: numerictype
					{
						pushFollow(FOLLOW_numerictype_in_simpletype1856);
						numerictype111 = numerictype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_numerictype.add(numerictype111.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(numerictype111 != null ? numerictype111.content
										: null);
						}

						// AST REWRITE
						// elements: numerictype
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 437:5: -> ^( SimpleType numerictype )
							{
								// ../rsc/CSharp.g3:437:8: ^( SimpleType numerictype )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												SimpleType,
												"SimpleType"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_numerictype.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:438:9: bOOL
					{
						pushFollow(FOLLOW_bOOL_in_simpletype1885);
						bOOL112 = bOOL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_bOOL.add(bOOL112.getTree());
						if (this.state.backtracking == 0) {
							retval.name = "bool";
						}

						// AST REWRITE
						// elements: bOOL
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 440:5: -> ^( SimpleType bOOL )
							{
								// ../rsc/CSharp.g3:440:8: ^( SimpleType bOOL )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												SimpleType,
												"SimpleType"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_bOOL.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "simpletype"

	public static class numerictype_return extends ParserRuleReturnScope {
		public String content;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "numerictype"
	// ../rsc/CSharp.g3:443:1: numerictype returns [String content] : ( integralType | floatingpointtype | dECIMAL );
	public final CSharpParser.numerictype_return numerictype()
			throws RecognitionException {
		CSharpParser.numerictype_return retval =
			new CSharpParser.numerictype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.integralType_return integralType113 = null;

		CSharpParser.floatingpointtype_return floatingpointtype114 = null;

		CSharpParser.dECIMAL_return dECIMAL115 = null;

		try {
			// ../rsc/CSharp.g3:444:5: ( integralType | floatingpointtype | dECIMAL )
			int alt17 = 3;
			switch (this.input.LA(1)) {
				case BYTE :
				case CHAR :
				case INT :
				case LONG :
				case SBYTE :
				case SHORT :
				case UINT :
				case ULONG :
				case USHORT :
					{
						alt17 = 1;
					}
					break;
				case DOUBLE :
				case FLOAT :
					{
						alt17 = 2;
					}
					break;
				case DECIMAL :
					{
						alt17 = 3;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 17, 0, this.input);

					throw nvae;
			}

			switch (alt17) {
				case 1 :
				// ../rsc/CSharp.g3:444:9: integralType
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_integralType_in_numerictype1927);
						integralType113 = integralType();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, integralType113.getTree());
						if (this.state.backtracking == 0) {
							retval.content =
								(integralType113 != null ? ((Token) integralType113.start)
										: null).getText();
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:445:9: floatingpointtype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_floatingpointtype_in_numerictype1939);
						floatingpointtype114 = floatingpointtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								floatingpointtype114.getTree());
						if (this.state.backtracking == 0) {
							retval.content =
								(floatingpointtype114 != null ? ((Token) floatingpointtype114.start)
										: null).getText();
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:446:9: dECIMAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dECIMAL_in_numerictype1951);
						dECIMAL115 = dECIMAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dECIMAL115.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "decimal";
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "numerictype"

	public static class integralType_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "integralType"
	// ../rsc/CSharp.g3:449:1: integralType : ( sBYTE | bYTE | sHORT | uSHORT | iNT | uINT | lONG | uLONG | cHAR );
	public final CSharpParser.integralType_return integralType()
			throws RecognitionException {
		CSharpParser.integralType_return retval =
			new CSharpParser.integralType_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.sBYTE_return sBYTE116 = null;

		CSharpParser.bYTE_return bYTE117 = null;

		CSharpParser.sHORT_return sHORT118 = null;

		CSharpParser.uSHORT_return uSHORT119 = null;

		CSharpParser.iNT_return iNT120 = null;

		CSharpParser.uINT_return uINT121 = null;

		CSharpParser.lONG_return lONG122 = null;

		CSharpParser.uLONG_return uLONG123 = null;

		CSharpParser.cHAR_return cHAR124 = null;

		try {
			// ../rsc/CSharp.g3:450:5: ( sBYTE | bYTE | sHORT | uSHORT | iNT | uINT | lONG | uLONG | cHAR )
			int alt18 = 9;
			alt18 = this.dfa18.predict(this.input);
			switch (alt18) {
				case 1 :
				// ../rsc/CSharp.g3:450:9: sBYTE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sBYTE_in_integralType1972);
						sBYTE116 = sBYTE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sBYTE116.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:451:9: bYTE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bYTE_in_integralType1982);
						bYTE117 = bYTE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bYTE117.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:452:9: sHORT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sHORT_in_integralType1992);
						sHORT118 = sHORT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sHORT118.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:453:9: uSHORT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uSHORT_in_integralType2002);
						uSHORT119 = uSHORT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uSHORT119.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:454:9: iNT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNT_in_integralType2012);
						iNT120 = iNT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNT120.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:455:9: uINT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uINT_in_integralType2022);
						uINT121 = uINT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uINT121.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:456:9: lONG
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lONG_in_integralType2032);
						lONG122 = lONG();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, lONG122.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:457:9: uLONG
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uLONG_in_integralType2042);
						uLONG123 = uLONG();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uLONG123.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:458:9: cHAR
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cHAR_in_integralType2052);
						cHAR124 = cHAR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cHAR124.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "integralType"

	public static class floatingpointtype_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "floatingpointtype"
	// ../rsc/CSharp.g3:461:1: floatingpointtype : ( fLOAT | dOUBLE );
	public final CSharpParser.floatingpointtype_return floatingpointtype()
			throws RecognitionException {
		CSharpParser.floatingpointtype_return retval =
			new CSharpParser.floatingpointtype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.fLOAT_return fLOAT125 = null;

		CSharpParser.dOUBLE_return dOUBLE126 = null;

		try {
			// ../rsc/CSharp.g3:462:5: ( fLOAT | dOUBLE )
			int alt19 = 2;
			int LA19_0 = this.input.LA(1);

			if ((LA19_0 == FLOAT)) {
				alt19 = 1;
			}
			else if ((LA19_0 == DOUBLE)) {
				alt19 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 19, 0, this.input);

				throw nvae;
			}
			switch (alt19) {
				case 1 :
				// ../rsc/CSharp.g3:462:9: fLOAT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fLOAT_in_floatingpointtype2071);
						fLOAT125 = fLOAT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fLOAT125.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:463:9: dOUBLE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dOUBLE_in_floatingpointtype2081);
						dOUBLE126 = dOUBLE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dOUBLE126.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "floatingpointtype"

	public static class enumtype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "enumtype"
	// ../rsc/CSharp.g3:466:1: enumtype returns [String name] : typename ;
	public final CSharpParser.enumtype_return enumtype()
			throws RecognitionException {
		CSharpParser.enumtype_return retval =
			new CSharpParser.enumtype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.typename_return typename127 = null;

		try {
			// ../rsc/CSharp.g3:467:5: ( typename )
			// ../rsc/CSharp.g3:467:9: typename
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_typename_in_enumtype2104);
				typename127 = typename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, typename127.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(typename127 != null ? typename127.name : null);
				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "enumtype"

	public static class nullabletype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "nullabletype"
	// ../rsc/CSharp.g3:471:1: nullabletype returns [String name] : nonnullablevaluetype qUESTION -> ^( NullableType nonnullablevaluetype qUESTION ) ;
	public final CSharpParser.nullabletype_return nullabletype()
			throws RecognitionException {
		CSharpParser.nullabletype_return retval =
			new CSharpParser.nullabletype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nonnullablevaluetype_return nonnullablevaluetype128 = null;

		CSharpParser.qUESTION_return qUESTION129 = null;

		RewriteRuleSubtreeStream stream_qUESTION =
			new RewriteRuleSubtreeStream(this.adaptor, "rule qUESTION");
		RewriteRuleSubtreeStream stream_nonnullablevaluetype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nonnullablevaluetype");
		try {
			// ../rsc/CSharp.g3:472:5: ( nonnullablevaluetype qUESTION -> ^( NullableType nonnullablevaluetype qUESTION ) )
			// ../rsc/CSharp.g3:472:9: nonnullablevaluetype qUESTION
			{
				pushFollow(FOLLOW_nonnullablevaluetype_in_nullabletype2134);
				nonnullablevaluetype128 = nonnullablevaluetype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_nonnullablevaluetype.add(nonnullablevaluetype128
						.getTree());
				pushFollow(FOLLOW_qUESTION_in_nullabletype2136);
				qUESTION129 = qUESTION();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_qUESTION.add(qUESTION129.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(nonnullablevaluetype128 != null ? nonnullablevaluetype128.name
								: null) + '?';
				}

				// AST REWRITE
				// elements: nonnullablevaluetype, qUESTION
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 474:5: -> ^( NullableType nonnullablevaluetype qUESTION )
					{
						// ../rsc/CSharp.g3:474:8: ^( NullableType nonnullablevaluetype qUESTION )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										NullableType,
										"NullableType"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_nonnullablevaluetype.nextTree());
							this.adaptor
								.addChild(root_1, stream_qUESTION.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "nullabletype"

	public static class nonnullablevaluetype_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "nonnullablevaluetype"
	// ../rsc/CSharp.g3:477:1: nonnullablevaluetype returns [String name] : ( enumtype | typename | simpletype );
	public final CSharpParser.nonnullablevaluetype_return nonnullablevaluetype()
			throws RecognitionException {
		CSharpParser.nonnullablevaluetype_return retval =
			new CSharpParser.nonnullablevaluetype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.enumtype_return enumtype130 = null;

		CSharpParser.typename_return typename131 = null;

		CSharpParser.simpletype_return simpletype132 = null;

		try {
			// ../rsc/CSharp.g3:478:5: ( enumtype | typename | simpletype )
			int alt20 = 3;
			alt20 = this.dfa20.predict(this.input);
			switch (alt20) {
				case 1 :
				// ../rsc/CSharp.g3:478:9: enumtype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_enumtype_in_nonnullablevaluetype2180);
						enumtype130 = enumtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, enumtype130.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(enumtype130 != null ? enumtype130.name : null);
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:480:7: typename
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_typename_in_nonnullablevaluetype2195);
						typename131 = typename();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, typename131.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(typename131 != null ? typename131.name : null);
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:482:9: simpletype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_simpletype_in_nonnullablevaluetype2212);
						simpletype132 = simpletype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, simpletype132.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(simpletype132 != null ? simpletype132.name
										: null);
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "nonnullablevaluetype"

	public static class referencetype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "referencetype"
	// ../rsc/CSharp.g3:486:1: referencetype returns [String name] : ( arraytype | classtype | interfacetype | delegatetype );
	public final CSharpParser.referencetype_return referencetype()
			throws RecognitionException {
		CSharpParser.referencetype_return retval =
			new CSharpParser.referencetype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.arraytype_return arraytype133 = null;

		CSharpParser.classtype_return classtype134 = null;

		CSharpParser.interfacetype_return interfacetype135 = null;

		CSharpParser.delegatetype_return delegatetype136 = null;

		try {
			// ../rsc/CSharp.g3:487:5: ( arraytype | classtype | interfacetype | delegatetype )
			int alt21 = 4;
			alt21 = this.dfa21.predict(this.input);
			switch (alt21) {
				case 1 :
				// ../rsc/CSharp.g3:487:9: arraytype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_arraytype_in_referencetype2242);
						arraytype133 = arraytype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, arraytype133.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(arraytype133 != null ? arraytype133.signature
										: null);
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:489:7: classtype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_classtype_in_referencetype2266);
						classtype134 = classtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, classtype134.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(classtype134 != null ? classtype134.name
										: null);
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:491:9: interfacetype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_interfacetype_in_referencetype2283);
						interfacetype135 = interfacetype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor
								.addChild(root_0, interfacetype135.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(interfacetype135 != null ? interfacetype135.name
										: null);
						}

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:493:9: delegatetype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_delegatetype_in_referencetype2300);
						delegatetype136 = delegatetype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, delegatetype136.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(delegatetype136 != null ? delegatetype136.name
										: null);
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "referencetype"

	public static class classtype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "classtype"
	// ../rsc/CSharp.g3:497:1: classtype returns [String name] : ( typename | oBJECT | sTRING );
	public final CSharpParser.classtype_return classtype()
			throws RecognitionException {
		CSharpParser.classtype_return retval =
			new CSharpParser.classtype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.typename_return typename137 = null;

		CSharpParser.oBJECT_return oBJECT138 = null;

		CSharpParser.sTRING_return sTRING139 = null;

		try {
			// ../rsc/CSharp.g3:498:5: ( typename | oBJECT | sTRING )
			int alt22 = 3;
			switch (this.input.LA(1)) {
				case ADD :
				case ALIAS :
				case GET :
				case PARTIAL :
				case REMOVE :
				case SET :
				case WHERE :
				case YIELD :
				case Ident :
					{
						alt22 = 1;
					}
					break;
				case OBJECT :
					{
						alt22 = 2;
					}
					break;
				case STRING :
					{
						alt22 = 3;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 22, 0, this.input);

					throw nvae;
			}

			switch (alt22) {
				case 1 :
				// ../rsc/CSharp.g3:498:9: typename
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_typename_in_classtype2330);
						typename137 = typename();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, typename137.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(typename137 != null ? typename137.name : null);
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:500:9: oBJECT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oBJECT_in_classtype2347);
						oBJECT138 = oBJECT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oBJECT138.getTree());
						if (this.state.backtracking == 0) {
							retval.name = "object";
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:502:9: sTRING
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTRING_in_classtype2364);
						sTRING139 = sTRING();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTRING139.getTree());
						if (this.state.backtracking == 0) {
							retval.name = "string";
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "classtype"

	public static class interfacetype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacetype"
	// ../rsc/CSharp.g3:506:1: interfacetype returns [String name] : typename ;
	public final CSharpParser.interfacetype_return interfacetype()
			throws RecognitionException {
		CSharpParser.interfacetype_return retval =
			new CSharpParser.interfacetype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.typename_return typename140 = null;

		try {
			// ../rsc/CSharp.g3:507:5: ( typename )
			// ../rsc/CSharp.g3:507:9: typename
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_typename_in_interfacetype2394);
				typename140 = typename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, typename140.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(typename140 != null ? typename140.name : null);
				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacetype"

	public static class delegatetype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "delegatetype"
	// ../rsc/CSharp.g3:511:1: delegatetype returns [String name] : typename ;
	public final CSharpParser.delegatetype_return delegatetype()
			throws RecognitionException {
		CSharpParser.delegatetype_return retval =
			new CSharpParser.delegatetype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.typename_return typename141 = null;

		try {
			// ../rsc/CSharp.g3:512:5: ( typename )
			// ../rsc/CSharp.g3:512:9: typename
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_typename_in_delegatetype2424);
				typename141 = typename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, typename141.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(typename141 != null ? typename141.name : null);
				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "delegatetype"

	public static class variablereference_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "variablereference"
	// ../rsc/CSharp.g3:517:1: variablereference : expression ;
	public final CSharpParser.variablereference_return variablereference()
			throws RecognitionException {
		CSharpParser.variablereference_return retval =
			new CSharpParser.variablereference_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.expression_return expression142 = null;

		try {
			// ../rsc/CSharp.g3:518:5: ( expression )
			// ../rsc/CSharp.g3:518:9: expression
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_expression_in_variablereference2451);
				expression142 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, expression142.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "variablereference"

	public static class argumentlist_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "argumentlist"
	// ../rsc/CSharp.g3:523:1: argumentlist : argument ( cOMMA argument )* -> ^( ArgumentList argument ( cOMMA argument )* ) ;
	public final CSharpParser.argumentlist_return argumentlist()
			throws RecognitionException {
		CSharpParser.argumentlist_return retval =
			new CSharpParser.argumentlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.argument_return argument143 = null;

		CSharpParser.cOMMA_return cOMMA144 = null;

		CSharpParser.argument_return argument145 = null;

		RewriteRuleSubtreeStream stream_argument =
			new RewriteRuleSubtreeStream(this.adaptor, "rule argument");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		try {
			// ../rsc/CSharp.g3:524:5: ( argument ( cOMMA argument )* -> ^( ArgumentList argument ( cOMMA argument )* ) )
			// ../rsc/CSharp.g3:524:9: argument ( cOMMA argument )*
			{
				pushFollow(FOLLOW_argument_in_argumentlist2473);
				argument143 = argument();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_argument.add(argument143.getTree());
				// ../rsc/CSharp.g3:524:18: ( cOMMA argument )*
				loop23: do {
					int alt23 = 2;
					int LA23_0 = this.input.LA(1);

					if ((LA23_0 == COMMA)) {
						alt23 = 1;
					}

					switch (alt23) {
						case 1 :
						// ../rsc/CSharp.g3:524:19: cOMMA argument
							{
								pushFollow(FOLLOW_cOMMA_in_argumentlist2476);
								cOMMA144 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_cOMMA.add(cOMMA144.getTree());
								pushFollow(FOLLOW_argument_in_argumentlist2478);
								argument145 = argument();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_argument.add(argument145.getTree());

							}
							break;

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

				// AST REWRITE
				// elements: argument, cOMMA, argument
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 525:5: -> ^( ArgumentList argument ( cOMMA argument )* )
					{
						// ../rsc/CSharp.g3:525:8: ^( ArgumentList argument ( cOMMA argument )* )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ArgumentList,
										"ArgumentList"),
									root_1);

							this.adaptor
								.addChild(root_1, stream_argument.nextTree());
							// ../rsc/CSharp.g3:525:32: ( cOMMA argument )*
							while (stream_cOMMA.hasNext()
									|| stream_argument.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_cOMMA.nextTree());
								this.adaptor.addChild(
									root_1,
									stream_argument.nextTree());

							}
							stream_cOMMA.reset();
							stream_argument.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "argumentlist"

	public static class argument_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "argument"
	// ../rsc/CSharp.g3:528:1: argument : ( expression -> ^( Argument expression ) | rEF variablereference -> ^( Argument rEF variablereference ) | oUT variablereference -> ^( Argument oUT variablereference ) );
	public final CSharpParser.argument_return argument()
			throws RecognitionException {
		CSharpParser.argument_return retval =
			new CSharpParser.argument_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.expression_return expression146 = null;

		CSharpParser.rEF_return rEF147 = null;

		CSharpParser.variablereference_return variablereference148 = null;

		CSharpParser.oUT_return oUT149 = null;

		CSharpParser.variablereference_return variablereference150 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_variablereference =
			new RewriteRuleSubtreeStream(this.adaptor, "rule variablereference");
		RewriteRuleSubtreeStream stream_oUT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule oUT");
		RewriteRuleSubtreeStream stream_rEF =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rEF");
		try {
			// ../rsc/CSharp.g3:529:5: ( expression -> ^( Argument expression ) | rEF variablereference -> ^( Argument rEF variablereference ) | oUT variablereference -> ^( Argument oUT variablereference ) )
			int alt24 = 3;
			switch (this.input.LA(1)) {
				case LPAREN :
				case PLUS :
				case MINUS :
				case EXCLAM :
				case TILDE :
				case INCREMENT :
				case DECREMENT :
				case BASE :
				case BOOL :
				case BYTE :
				case CHAR :
				case CHECKED :
				case DECIMAL :
				case DEFAULT :
				case DELEGATE :
				case DOUBLE :
				case FALSE :
				case FLOAT :
				case INT :
				case LONG :
				case NEW :
				case NULL :
				case OBJECT :
				case SBYTE :
				case SHORT :
				case STRING :
				case THIS :
				case TRUE :
				case TYPEOF :
				case UINT :
				case ULONG :
				case UNCHECKED :
				case USHORT :
				case ADD :
				case ALIAS :
				case GET :
				case PARTIAL :
				case REMOVE :
				case SET :
				case WHERE :
				case YIELD :
				case Ident :
				case Integerliteral :
				case Realliteral :
				case Characterliteral :
				case Stringliteral :
					{
						alt24 = 1;
					}
					break;
				case REF :
					{
						alt24 = 2;
					}
					break;
				case OUT :
					{
						alt24 = 3;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 24, 0, this.input);

					throw nvae;
			}

			switch (alt24) {
				case 1 :
				// ../rsc/CSharp.g3:529:7: expression
					{
						pushFollow(FOLLOW_expression_in_argument2516);
						expression146 = expression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_expression.add(expression146.getTree());

						// AST REWRITE
						// elements: expression
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 530:5: -> ^( Argument expression )
							{
								// ../rsc/CSharp.g3:530:8: ^( Argument expression )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Argument,
												"Argument"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_expression.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:531:9: rEF variablereference
					{
						pushFollow(FOLLOW_rEF_in_argument2538);
						rEF147 = rEF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rEF.add(rEF147.getTree());
						pushFollow(FOLLOW_variablereference_in_argument2540);
						variablereference148 = variablereference();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_variablereference.add(variablereference148
								.getTree());

						// AST REWRITE
						// elements: rEF, variablereference
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 532:5: -> ^( Argument rEF variablereference )
							{
								// ../rsc/CSharp.g3:532:8: ^( Argument rEF variablereference )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Argument,
												"Argument"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_rEF.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_variablereference.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:533:9: oUT variablereference
					{
						pushFollow(FOLLOW_oUT_in_argument2564);
						oUT149 = oUT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_oUT.add(oUT149.getTree());
						pushFollow(FOLLOW_variablereference_in_argument2566);
						variablereference150 = variablereference();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_variablereference.add(variablereference150
								.getTree());

						// AST REWRITE
						// elements: oUT, variablereference
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 534:5: -> ^( Argument oUT variablereference )
							{
								// ../rsc/CSharp.g3:534:8: ^( Argument oUT variablereference )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Argument,
												"Argument"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_oUT.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_variablereference.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "argument"

	public static class primaryexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "primaryexpression"
	// ../rsc/CSharp.g3:547:1: primaryexpression options {memoize=true; } : ( primarynoarraycreationexpression | arraycreationexpression_withoutinitializer );
	public final CSharpParser.primaryexpression_return primaryexpression()
			throws RecognitionException {
		CSharpParser.primaryexpression_return retval =
			new CSharpParser.primaryexpression_return();
		retval.start = this.input.LT(1);
		int primaryexpression_StartIndex = this.input.index();
		Object root_0 = null;

		CSharpParser.primarynoarraycreationexpression_return primarynoarraycreationexpression151 =
			null;

		CSharpParser.arraycreationexpression_withoutinitializer_return arraycreationexpression_withoutinitializer152 =
			null;

		try {
			if (this.state.backtracking > 0 && alreadyParsedRule(this.input, 25)) {
				return retval;
			}
			// ../rsc/CSharp.g3:562:2: ( primarynoarraycreationexpression | arraycreationexpression_withoutinitializer )
			int alt25 = 2;
			alt25 = this.dfa25.predict(this.input);
			switch (alt25) {
				case 1 :
				// ../rsc/CSharp.g3:562:4: primarynoarraycreationexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_primarynoarraycreationexpression_in_primaryexpression2613);
						primarynoarraycreationexpression151 =
							primarynoarraycreationexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								primarynoarraycreationexpression151.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:563:4: arraycreationexpression_withoutinitializer
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_arraycreationexpression_withoutinitializer_in_primaryexpression2618);
						arraycreationexpression_withoutinitializer152 =
							arraycreationexpression_withoutinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								arraycreationexpression_withoutinitializer152
									.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
			if (this.state.backtracking > 0) {
				memoize(this.input, 25, primaryexpression_StartIndex);
			}
		}
		return retval;
	}
	// $ANTLR end "primaryexpression"

	public static class primary_nonrec_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "primary_nonrec"
	// ../rsc/CSharp.g3:567:1: primary_nonrec : ( arraycreationexpression_withoutinitializer | primarynoarray_nonrec );
	public final CSharpParser.primary_nonrec_return primary_nonrec()
			throws RecognitionException {
		CSharpParser.primary_nonrec_return retval =
			new CSharpParser.primary_nonrec_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.arraycreationexpression_withoutinitializer_return arraycreationexpression_withoutinitializer153 =
			null;

		CSharpParser.primarynoarray_nonrec_return primarynoarray_nonrec154 =
			null;

		try {
			// ../rsc/CSharp.g3:568:2: ( arraycreationexpression_withoutinitializer | primarynoarray_nonrec )
			int alt26 = 2;
			alt26 = this.dfa26.predict(this.input);
			switch (alt26) {
				case 1 :
				// ../rsc/CSharp.g3:568:4: arraycreationexpression_withoutinitializer
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_arraycreationexpression_withoutinitializer_in_primary_nonrec2630);
						arraycreationexpression_withoutinitializer153 =
							arraycreationexpression_withoutinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								arraycreationexpression_withoutinitializer153
									.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:569:4: primarynoarray_nonrec
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_primarynoarray_nonrec_in_primary_nonrec2635);
						primarynoarray_nonrec154 = primarynoarray_nonrec();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								primarynoarray_nonrec154.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "primary_nonrec"

	public static class primarynoarraycreationexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "primarynoarraycreationexpression"
	// ../rsc/CSharp.g3:572:1: primarynoarraycreationexpression : ( memberaccess_rec_rest | invocationexpression | elementaccess | postincrementexpression | postdecrementexpression | primarynoarray_nonrec );
	public final CSharpParser.primarynoarraycreationexpression_return primarynoarraycreationexpression()
			throws RecognitionException {
		CSharpParser.primarynoarraycreationexpression_return retval =
			new CSharpParser.primarynoarraycreationexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.memberaccess_rec_rest_return memberaccess_rec_rest155 =
			null;

		CSharpParser.invocationexpression_return invocationexpression156 = null;

		CSharpParser.elementaccess_return elementaccess157 = null;

		CSharpParser.postincrementexpression_return postincrementexpression158 =
			null;

		CSharpParser.postdecrementexpression_return postdecrementexpression159 =
			null;

		CSharpParser.primarynoarray_nonrec_return primarynoarray_nonrec160 =
			null;

		try {
			// ../rsc/CSharp.g3:573:2: ( memberaccess_rec_rest | invocationexpression | elementaccess | postincrementexpression | postdecrementexpression | primarynoarray_nonrec )
			int alt27 = 6;
			alt27 = this.dfa27.predict(this.input);
			switch (alt27) {
				case 1 :
				// ../rsc/CSharp.g3:573:4: memberaccess_rec_rest
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_memberaccess_rec_rest_in_primarynoarraycreationexpression2646);
						memberaccess_rec_rest155 = memberaccess_rec_rest();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								memberaccess_rec_rest155.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:574:4: invocationexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_invocationexpression_in_primarynoarraycreationexpression2651);
						invocationexpression156 = invocationexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								invocationexpression156.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:575:4: elementaccess
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_elementaccess_in_primarynoarraycreationexpression2656);
						elementaccess157 = elementaccess();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor
								.addChild(root_0, elementaccess157.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:576:4: postincrementexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_postincrementexpression_in_primarynoarraycreationexpression2661);
						postincrementexpression158 = postincrementexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								postincrementexpression158.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:577:4: postdecrementexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_postdecrementexpression_in_primarynoarraycreationexpression2666);
						postdecrementexpression159 = postdecrementexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								postdecrementexpression159.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:578:4: primarynoarray_nonrec
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_primarynoarray_nonrec_in_primarynoarraycreationexpression2671);
						primarynoarray_nonrec160 = primarynoarray_nonrec();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								primarynoarray_nonrec160.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "primarynoarraycreationexpression"

	public static class primarynoarray_nonrec_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "primarynoarray_nonrec"
	// ../rsc/CSharp.g3:582:1: primarynoarray_nonrec : ( arraycreationexpression_withinitializer | literal | simplename | parenthesizedexpression | memberaccess_nonrec | thisaccess | baseaccess | objectcreationexpression | typeofexpression | checkedexpression | uncheckedexpression | defaultvalueexpression | anonymousmethodexpression );
	public final CSharpParser.primarynoarray_nonrec_return primarynoarray_nonrec()
			throws RecognitionException {
		CSharpParser.primarynoarray_nonrec_return retval =
			new CSharpParser.primarynoarray_nonrec_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.arraycreationexpression_withinitializer_return arraycreationexpression_withinitializer161 =
			null;

		CSharpParser.literal_return literal162 = null;

		CSharpParser.simplename_return simplename163 = null;

		CSharpParser.parenthesizedexpression_return parenthesizedexpression164 =
			null;

		CSharpParser.memberaccess_nonrec_return memberaccess_nonrec165 = null;

		CSharpParser.thisaccess_return thisaccess166 = null;

		CSharpParser.baseaccess_return baseaccess167 = null;

		CSharpParser.objectcreationexpression_return objectcreationexpression168 =
			null;

		CSharpParser.typeofexpression_return typeofexpression169 = null;

		CSharpParser.checkedexpression_return checkedexpression170 = null;

		CSharpParser.uncheckedexpression_return uncheckedexpression171 = null;

		CSharpParser.defaultvalueexpression_return defaultvalueexpression172 =
			null;

		CSharpParser.anonymousmethodexpression_return anonymousmethodexpression173 =
			null;

		try {
			// ../rsc/CSharp.g3:587:2: ( arraycreationexpression_withinitializer | literal | simplename | parenthesizedexpression | memberaccess_nonrec | thisaccess | baseaccess | objectcreationexpression | typeofexpression | checkedexpression | uncheckedexpression | defaultvalueexpression | anonymousmethodexpression )
			int alt28 = 13;
			alt28 = this.dfa28.predict(this.input);
			switch (alt28) {
				case 1 :
				// ../rsc/CSharp.g3:587:5: arraycreationexpression_withinitializer
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_arraycreationexpression_withinitializer_in_primarynoarray_nonrec2686);
						arraycreationexpression_withinitializer161 =
							arraycreationexpression_withinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								arraycreationexpression_withinitializer161
									.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:588:4: literal
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_literal_in_primarynoarray_nonrec2691);
						literal162 = literal();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, literal162.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:589:4: simplename
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_simplename_in_primarynoarray_nonrec2696);
						simplename163 = simplename();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, simplename163.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:590:4: parenthesizedexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_parenthesizedexpression_in_primarynoarray_nonrec2701);
						parenthesizedexpression164 = parenthesizedexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								parenthesizedexpression164.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:591:4: memberaccess_nonrec
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_memberaccess_nonrec_in_primarynoarray_nonrec2706);
						memberaccess_nonrec165 = memberaccess_nonrec();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								memberaccess_nonrec165.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:592:4: thisaccess
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_thisaccess_in_primarynoarray_nonrec2711);
						thisaccess166 = thisaccess();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, thisaccess166.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:593:4: baseaccess
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_baseaccess_in_primarynoarray_nonrec2716);
						baseaccess167 = baseaccess();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, baseaccess167.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:594:4: objectcreationexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_objectcreationexpression_in_primarynoarray_nonrec2721);
						objectcreationexpression168 =
							objectcreationexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								objectcreationexpression168.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:596:4: typeofexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_typeofexpression_in_primarynoarray_nonrec2727);
						typeofexpression169 = typeofexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								typeofexpression169.getTree());

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:597:4: checkedexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_checkedexpression_in_primarynoarray_nonrec2732);
						checkedexpression170 = checkedexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								checkedexpression170.getTree());

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:598:4: uncheckedexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uncheckedexpression_in_primarynoarray_nonrec2737);
						uncheckedexpression171 = uncheckedexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								uncheckedexpression171.getTree());

					}
					break;
				case 12 :
				// ../rsc/CSharp.g3:599:4: defaultvalueexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_defaultvalueexpression_in_primarynoarray_nonrec2742);
						defaultvalueexpression172 = defaultvalueexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								defaultvalueexpression172.getTree());

					}
					break;
				case 13 :
				// ../rsc/CSharp.g3:600:4: anonymousmethodexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_anonymousmethodexpression_in_primarynoarray_nonrec2747);
						anonymousmethodexpression173 =
							anonymousmethodexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								anonymousmethodexpression173.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "primarynoarray_nonrec"

	public static class memberaccess_nonrec_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "memberaccess_nonrec"
	// ../rsc/CSharp.g3:603:1: memberaccess_nonrec : ( predefinedtype dOT identifier ( typeargumentlist )? -> ^( MemberAccess predefinedtype dOT identifier ( typeargumentlist )? ) | qualifiedaliasmember dOT identifier ( typeargumentlist )? -> ^( MemberAccess qualifiedaliasmember dOT identifier ( typeargumentlist )? ) );
	public final CSharpParser.memberaccess_nonrec_return memberaccess_nonrec()
			throws RecognitionException {
		CSharpParser.memberaccess_nonrec_return retval =
			new CSharpParser.memberaccess_nonrec_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.predefinedtype_return predefinedtype174 = null;

		CSharpParser.dOT_return dOT175 = null;

		CSharpParser.identifier_return identifier176 = null;

		CSharpParser.typeargumentlist_return typeargumentlist177 = null;

		CSharpParser.qualifiedaliasmember_return qualifiedaliasmember178 = null;

		CSharpParser.dOT_return dOT179 = null;

		CSharpParser.identifier_return identifier180 = null;

		CSharpParser.typeargumentlist_return typeargumentlist181 = null;

		RewriteRuleSubtreeStream stream_dOT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dOT");
		RewriteRuleSubtreeStream stream_qualifiedaliasmember =
			new RewriteRuleSubtreeStream(this.adaptor, "rule qualifiedaliasmember");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_typeargumentlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeargumentlist");
		RewriteRuleSubtreeStream stream_predefinedtype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule predefinedtype");
		try {
			// ../rsc/CSharp.g3:607:2: ( predefinedtype dOT identifier ( typeargumentlist )? -> ^( MemberAccess predefinedtype dOT identifier ( typeargumentlist )? ) | qualifiedaliasmember dOT identifier ( typeargumentlist )? -> ^( MemberAccess qualifiedaliasmember dOT identifier ( typeargumentlist )? ) )
			int alt31 = 2;
			int LA31_0 = this.input.LA(1);

			if ((LA31_0 == BOOL || LA31_0 == BYTE || LA31_0 == CHAR
					|| LA31_0 == DECIMAL || LA31_0 == DOUBLE || LA31_0 == FLOAT
					|| LA31_0 == INT || LA31_0 == LONG || LA31_0 == OBJECT
					|| LA31_0 == SBYTE || LA31_0 == SHORT || LA31_0 == STRING
					|| (LA31_0 >= UINT && LA31_0 <= ULONG) || LA31_0 == USHORT)) {
				alt31 = 1;
			}
			else if (((LA31_0 >= ADD && LA31_0 <= Ident))) {
				alt31 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 31, 0, this.input);

				throw nvae;
			}
			switch (alt31) {
				case 1 :
				// ../rsc/CSharp.g3:607:4: predefinedtype dOT identifier ( typeargumentlist )?
					{
						pushFollow(FOLLOW_predefinedtype_in_memberaccess_nonrec2760);
						predefinedtype174 = predefinedtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_predefinedtype.add(predefinedtype174
								.getTree());
						pushFollow(FOLLOW_dOT_in_memberaccess_nonrec2762);
						dOT175 = dOT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_dOT.add(dOT175.getTree());
						pushFollow(FOLLOW_identifier_in_memberaccess_nonrec2764);
						identifier176 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier176.getTree());
						// ../rsc/CSharp.g3:607:34: ( typeargumentlist )?
						int alt29 = 2;
						alt29 = this.dfa29.predict(this.input);
						switch (alt29) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: typeargumentlist
								{
									pushFollow(FOLLOW_typeargumentlist_in_memberaccess_nonrec2766);
									typeargumentlist177 = typeargumentlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_typeargumentlist
											.add(typeargumentlist177.getTree());

								}
								break;

						}

						// AST REWRITE
						// elements: dOT, typeargumentlist, identifier, predefinedtype
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 608:2: -> ^( MemberAccess predefinedtype dOT identifier ( typeargumentlist )? )
							{
								// ../rsc/CSharp.g3:608:5: ^( MemberAccess predefinedtype dOT identifier ( typeargumentlist )? )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												MemberAccess,
												"MemberAccess"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_predefinedtype.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_dOT.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());
									// ../rsc/CSharp.g3:608:50: ( typeargumentlist )?
									if (stream_typeargumentlist.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_typeargumentlist.nextTree());

									}
									stream_typeargumentlist.reset();

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:609:4: qualifiedaliasmember dOT identifier ( typeargumentlist )?
					{
						pushFollow(FOLLOW_qualifiedaliasmember_in_memberaccess_nonrec2788);
						qualifiedaliasmember178 = qualifiedaliasmember();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_qualifiedaliasmember
								.add(qualifiedaliasmember178.getTree());
						pushFollow(FOLLOW_dOT_in_memberaccess_nonrec2790);
						dOT179 = dOT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_dOT.add(dOT179.getTree());
						pushFollow(FOLLOW_identifier_in_memberaccess_nonrec2792);
						identifier180 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier180.getTree());
						// ../rsc/CSharp.g3:609:40: ( typeargumentlist )?
						int alt30 = 2;
						alt30 = this.dfa30.predict(this.input);
						switch (alt30) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: typeargumentlist
								{
									pushFollow(FOLLOW_typeargumentlist_in_memberaccess_nonrec2794);
									typeargumentlist181 = typeargumentlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_typeargumentlist
											.add(typeargumentlist181.getTree());

								}
								break;

						}

						// AST REWRITE
						// elements: qualifiedaliasmember, dOT, identifier, typeargumentlist
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 610:2: -> ^( MemberAccess qualifiedaliasmember dOT identifier ( typeargumentlist )? )
							{
								// ../rsc/CSharp.g3:610:5: ^( MemberAccess qualifiedaliasmember dOT identifier ( typeargumentlist )? )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												MemberAccess,
												"MemberAccess"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_qualifiedaliasmember.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_dOT.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());
									// ../rsc/CSharp.g3:610:56: ( typeargumentlist )?
									if (stream_typeargumentlist.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_typeargumentlist.nextTree());

									}
									stream_typeargumentlist.reset();

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "memberaccess_nonrec"

	public static class memberaccess_rec_rest_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "memberaccess_rec_rest"
	// ../rsc/CSharp.g3:613:1: memberaccess_rec_rest : ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $memberaccess_rec_rest invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $memberaccess_rec_rest postdecrement_rest ) | elementaccess_rest -> ^( ElementAccess $memberaccess_rec_rest elementaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $memberaccess_rec_rest postincrement_rest ) )* memberaccess_rest -> ^( MemberAccess $memberaccess_rec_rest memberaccess_rest ) )+ ;
	public final CSharpParser.memberaccess_rec_rest_return memberaccess_rec_rest()
			throws RecognitionException {
		CSharpParser.memberaccess_rec_rest_return retval =
			new CSharpParser.memberaccess_rec_rest_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.primary_nonrec_return primary_nonrec182 = null;

		CSharpParser.invocation_rest_return invocation_rest183 = null;

		CSharpParser.postdecrement_rest_return postdecrement_rest184 = null;

		CSharpParser.elementaccess_rest_return elementaccess_rest185 = null;

		CSharpParser.postincrement_rest_return postincrement_rest186 = null;

		CSharpParser.memberaccess_rest_return memberaccess_rest187 = null;

		RewriteRuleSubtreeStream stream_invocation_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule invocation_rest");
		RewriteRuleSubtreeStream stream_postincrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postincrement_rest");
		RewriteRuleSubtreeStream stream_postdecrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postdecrement_rest");
		RewriteRuleSubtreeStream stream_memberaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule memberaccess_rest");
		RewriteRuleSubtreeStream stream_primary_nonrec =
			new RewriteRuleSubtreeStream(this.adaptor, "rule primary_nonrec");
		RewriteRuleSubtreeStream stream_elementaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule elementaccess_rest");
		try {
			// ../rsc/CSharp.g3:615:2: ( ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $memberaccess_rec_rest invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $memberaccess_rec_rest postdecrement_rest ) | elementaccess_rest -> ^( ElementAccess $memberaccess_rec_rest elementaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $memberaccess_rec_rest postincrement_rest ) )* memberaccess_rest -> ^( MemberAccess $memberaccess_rec_rest memberaccess_rest ) )+ )
			// ../rsc/CSharp.g3:615:4: ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $memberaccess_rec_rest invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $memberaccess_rec_rest postdecrement_rest ) | elementaccess_rest -> ^( ElementAccess $memberaccess_rec_rest elementaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $memberaccess_rec_rest postincrement_rest ) )* memberaccess_rest -> ^( MemberAccess $memberaccess_rec_rest memberaccess_rest ) )+
			{
				// ../rsc/CSharp.g3:615:4: ( primary_nonrec -> primary_nonrec )
				// ../rsc/CSharp.g3:615:5: primary_nonrec
				{
					pushFollow(FOLLOW_primary_nonrec_in_memberaccess_rec_rest2825);
					primary_nonrec182 = primary_nonrec();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_primary_nonrec.add(primary_nonrec182.getTree());

					// AST REWRITE
					// elements: primary_nonrec
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 615:20: -> primary_nonrec
						{
							this.adaptor.addChild(
								root_0,
								stream_primary_nonrec.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:616:3: ( ( invocation_rest -> ^( InvocationExpression $memberaccess_rec_rest invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $memberaccess_rec_rest postdecrement_rest ) | elementaccess_rest -> ^( ElementAccess $memberaccess_rec_rest elementaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $memberaccess_rec_rest postincrement_rest ) )* memberaccess_rest -> ^( MemberAccess $memberaccess_rec_rest memberaccess_rest ) )+
				int cnt33 = 0;
				loop33: do {
					int alt33 = 2;
					int LA33_0 = this.input.LA(1);

					if ((LA33_0 == LBRACKET || LA33_0 == LPAREN
							|| LA33_0 == DOT || (LA33_0 >= INCREMENT && LA33_0 <= DECREMENT))) {
						alt33 = 1;
					}

					switch (alt33) {
						case 1 :
						// ../rsc/CSharp.g3:617:4: ( invocation_rest -> ^( InvocationExpression $memberaccess_rec_rest invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $memberaccess_rec_rest postdecrement_rest ) | elementaccess_rest -> ^( ElementAccess $memberaccess_rec_rest elementaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $memberaccess_rec_rest postincrement_rest ) )* memberaccess_rest
							{
								// ../rsc/CSharp.g3:617:4: ( invocation_rest -> ^( InvocationExpression $memberaccess_rec_rest invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $memberaccess_rec_rest postdecrement_rest ) | elementaccess_rest -> ^( ElementAccess $memberaccess_rec_rest elementaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $memberaccess_rec_rest postincrement_rest ) )*
								loop32: do {
									int alt32 = 5;
									switch (this.input.LA(1)) {
										case LPAREN :
											{
												alt32 = 1;
											}
											break;
										case DECREMENT :
											{
												alt32 = 2;
											}
											break;
										case LBRACKET :
											{
												alt32 = 3;
											}
											break;
										case INCREMENT :
											{
												alt32 = 4;
											}
											break;

									}

									switch (alt32) {
										case 1 :
										// ../rsc/CSharp.g3:618:5: invocation_rest
											{
												pushFollow(FOLLOW_invocation_rest_in_memberaccess_rec_rest2845);
												invocation_rest183 =
													invocation_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_invocation_rest
														.add(invocation_rest183
															.getTree());

												// AST REWRITE
												// elements: invocation_rest, memberaccess_rec_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 618:21: -> ^( InvocationExpression $memberaccess_rec_rest invocation_rest )
													{
														// ../rsc/CSharp.g3:618:24: ^( InvocationExpression $memberaccess_rec_rest invocation_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				InvocationExpression,
																				"InvocationExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_invocation_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 2 :
										// ../rsc/CSharp.g3:619:6: postdecrement_rest
											{
												pushFollow(FOLLOW_postdecrement_rest_in_memberaccess_rec_rest2863);
												postdecrement_rest184 =
													postdecrement_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_postdecrement_rest
														.add(postdecrement_rest184
															.getTree());

												// AST REWRITE
												// elements: memberaccess_rec_rest, postdecrement_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 619:25: -> ^( PostDecrementExpression $memberaccess_rec_rest postdecrement_rest )
													{
														// ../rsc/CSharp.g3:619:28: ^( PostDecrementExpression $memberaccess_rec_rest postdecrement_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				PostDecrementExpression,
																				"PostDecrementExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_postdecrement_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 3 :
										// ../rsc/CSharp.g3:620:6: elementaccess_rest
											{
												pushFollow(FOLLOW_elementaccess_rest_in_memberaccess_rec_rest2881);
												elementaccess_rest185 =
													elementaccess_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_elementaccess_rest
														.add(elementaccess_rest185
															.getTree());

												// AST REWRITE
												// elements: elementaccess_rest, memberaccess_rec_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 620:25: -> ^( ElementAccess $memberaccess_rec_rest elementaccess_rest )
													{
														// ../rsc/CSharp.g3:620:28: ^( ElementAccess $memberaccess_rec_rest elementaccess_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				ElementAccess,
																				"ElementAccess"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_elementaccess_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 4 :
										// ../rsc/CSharp.g3:621:6: postincrement_rest
											{
												pushFollow(FOLLOW_postincrement_rest_in_memberaccess_rec_rest2899);
												postincrement_rest186 =
													postincrement_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_postincrement_rest
														.add(postincrement_rest186
															.getTree());

												// AST REWRITE
												// elements: postincrement_rest, memberaccess_rec_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 621:25: -> ^( PostIncrementExpression $memberaccess_rec_rest postincrement_rest )
													{
														// ../rsc/CSharp.g3:621:28: ^( PostIncrementExpression $memberaccess_rec_rest postincrement_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				PostIncrementExpression,
																				"PostIncrementExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_postincrement_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;

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

								pushFollow(FOLLOW_memberaccess_rest_in_memberaccess_rec_rest2921);
								memberaccess_rest187 = memberaccess_rest();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_memberaccess_rest
										.add(memberaccess_rest187.getTree());

								// AST REWRITE
								// elements: memberaccess_rest, memberaccess_rec_rest
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 623:22: -> ^( MemberAccess $memberaccess_rec_rest memberaccess_rest )
									{
										// ../rsc/CSharp.g3:623:25: ^( MemberAccess $memberaccess_rec_rest memberaccess_rest )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														MemberAccess,
														"MemberAccess"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_memberaccess_rest
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

						default :
							if (cnt33 >= 1)
								break loop33;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(33, this.input);
							throw eee;
					}
					cnt33++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "memberaccess_rec_rest"

	public static class memberaccess_rest_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "memberaccess_rest"
	// ../rsc/CSharp.g3:628:1: memberaccess_rest : dOT identifier ( typeargumentlist )? ;
	public final CSharpParser.memberaccess_rest_return memberaccess_rest()
			throws RecognitionException {
		CSharpParser.memberaccess_rest_return retval =
			new CSharpParser.memberaccess_rest_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.dOT_return dOT188 = null;

		CSharpParser.identifier_return identifier189 = null;

		CSharpParser.typeargumentlist_return typeargumentlist190 = null;

		try {
			// ../rsc/CSharp.g3:629:2: ( dOT identifier ( typeargumentlist )? )
			// ../rsc/CSharp.g3:629:4: dOT identifier ( typeargumentlist )?
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_dOT_in_memberaccess_rest2949);
				dOT188 = dOT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, dOT188.getTree());
				pushFollow(FOLLOW_identifier_in_memberaccess_rest2951);
				identifier189 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, identifier189.getTree());
				// ../rsc/CSharp.g3:629:19: ( typeargumentlist )?
				int alt34 = 2;
				alt34 = this.dfa34.predict(this.input);
				switch (alt34) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeargumentlist
						{
							pushFollow(FOLLOW_typeargumentlist_in_memberaccess_rest2953);
							typeargumentlist190 = typeargumentlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								this.adaptor.addChild(
									root_0,
									typeargumentlist190.getTree());

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "memberaccess_rest"

	public static class elementaccess_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "elementaccess"
	// ../rsc/CSharp.g3:632:1: elementaccess : ( primarynoarray_nonrec -> primarynoarray_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $elementaccess invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $elementaccess postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $elementaccess memberaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $elementaccess postincrement_rest ) )* elementaccess_rest -> ^( ElementAccess $elementaccess elementaccess_rest ) )+ ;
	public final CSharpParser.elementaccess_return elementaccess()
			throws RecognitionException {
		CSharpParser.elementaccess_return retval =
			new CSharpParser.elementaccess_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.primarynoarray_nonrec_return primarynoarray_nonrec191 =
			null;

		CSharpParser.invocation_rest_return invocation_rest192 = null;

		CSharpParser.postdecrement_rest_return postdecrement_rest193 = null;

		CSharpParser.memberaccess_rest_return memberaccess_rest194 = null;

		CSharpParser.postincrement_rest_return postincrement_rest195 = null;

		CSharpParser.elementaccess_rest_return elementaccess_rest196 = null;

		RewriteRuleSubtreeStream stream_invocation_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule invocation_rest");
		RewriteRuleSubtreeStream stream_postincrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postincrement_rest");
		RewriteRuleSubtreeStream stream_primarynoarray_nonrec =
			new RewriteRuleSubtreeStream(this.adaptor, "rule primarynoarray_nonrec");
		RewriteRuleSubtreeStream stream_postdecrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postdecrement_rest");
		RewriteRuleSubtreeStream stream_memberaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule memberaccess_rest");
		RewriteRuleSubtreeStream stream_elementaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule elementaccess_rest");
		try {
			// ../rsc/CSharp.g3:633:2: ( ( primarynoarray_nonrec -> primarynoarray_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $elementaccess invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $elementaccess postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $elementaccess memberaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $elementaccess postincrement_rest ) )* elementaccess_rest -> ^( ElementAccess $elementaccess elementaccess_rest ) )+ )
			// ../rsc/CSharp.g3:633:4: ( primarynoarray_nonrec -> primarynoarray_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $elementaccess invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $elementaccess postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $elementaccess memberaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $elementaccess postincrement_rest ) )* elementaccess_rest -> ^( ElementAccess $elementaccess elementaccess_rest ) )+
			{
				// ../rsc/CSharp.g3:633:4: ( primarynoarray_nonrec -> primarynoarray_nonrec )
				// ../rsc/CSharp.g3:633:5: primarynoarray_nonrec
				{
					pushFollow(FOLLOW_primarynoarray_nonrec_in_elementaccess2966);
					primarynoarray_nonrec191 = primarynoarray_nonrec();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_primarynoarray_nonrec
							.add(primarynoarray_nonrec191.getTree());

					// AST REWRITE
					// elements: primarynoarray_nonrec
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 633:27: -> primarynoarray_nonrec
						{
							this.adaptor.addChild(
								root_0,
								stream_primarynoarray_nonrec.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:634:3: ( ( invocation_rest -> ^( InvocationExpression $elementaccess invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $elementaccess postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $elementaccess memberaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $elementaccess postincrement_rest ) )* elementaccess_rest -> ^( ElementAccess $elementaccess elementaccess_rest ) )+
				int cnt36 = 0;
				loop36: do {
					int alt36 = 2;
					int LA36_0 = this.input.LA(1);

					if ((LA36_0 == LBRACKET || LA36_0 == LPAREN
							|| LA36_0 == DOT || (LA36_0 >= INCREMENT && LA36_0 <= DECREMENT))) {
						alt36 = 1;
					}

					switch (alt36) {
						case 1 :
						// ../rsc/CSharp.g3:635:4: ( invocation_rest -> ^( InvocationExpression $elementaccess invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $elementaccess postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $elementaccess memberaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $elementaccess postincrement_rest ) )* elementaccess_rest
							{
								// ../rsc/CSharp.g3:635:4: ( invocation_rest -> ^( InvocationExpression $elementaccess invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $elementaccess postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $elementaccess memberaccess_rest ) | postincrement_rest -> ^( PostIncrementExpression $elementaccess postincrement_rest ) )*
								loop35: do {
									int alt35 = 5;
									switch (this.input.LA(1)) {
										case LPAREN :
											{
												alt35 = 1;
											}
											break;
										case DECREMENT :
											{
												alt35 = 2;
											}
											break;
										case DOT :
											{
												alt35 = 3;
											}
											break;
										case INCREMENT :
											{
												alt35 = 4;
											}
											break;

									}

									switch (alt35) {
										case 1 :
										// ../rsc/CSharp.g3:636:5: invocation_rest
											{
												pushFollow(FOLLOW_invocation_rest_in_elementaccess2986);
												invocation_rest192 =
													invocation_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_invocation_rest
														.add(invocation_rest192
															.getTree());

												// AST REWRITE
												// elements: elementaccess, invocation_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 636:21: -> ^( InvocationExpression $elementaccess invocation_rest )
													{
														// ../rsc/CSharp.g3:636:24: ^( InvocationExpression $elementaccess invocation_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				InvocationExpression,
																				"InvocationExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_invocation_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 2 :
										// ../rsc/CSharp.g3:637:6: postdecrement_rest
											{
												pushFollow(FOLLOW_postdecrement_rest_in_elementaccess3004);
												postdecrement_rest193 =
													postdecrement_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_postdecrement_rest
														.add(postdecrement_rest193
															.getTree());

												// AST REWRITE
												// elements: elementaccess, postdecrement_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 637:25: -> ^( PostDecrementExpression $elementaccess postdecrement_rest )
													{
														// ../rsc/CSharp.g3:637:28: ^( PostDecrementExpression $elementaccess postdecrement_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				PostDecrementExpression,
																				"PostDecrementExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_postdecrement_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 3 :
										// ../rsc/CSharp.g3:638:6: memberaccess_rest
											{
												pushFollow(FOLLOW_memberaccess_rest_in_elementaccess3022);
												memberaccess_rest194 =
													memberaccess_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_memberaccess_rest
														.add(memberaccess_rest194
															.getTree());

												// AST REWRITE
												// elements: elementaccess, memberaccess_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 638:24: -> ^( MemberAccess $elementaccess memberaccess_rest )
													{
														// ../rsc/CSharp.g3:638:27: ^( MemberAccess $elementaccess memberaccess_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				MemberAccess,
																				"MemberAccess"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_memberaccess_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 4 :
										// ../rsc/CSharp.g3:639:6: postincrement_rest
											{
												pushFollow(FOLLOW_postincrement_rest_in_elementaccess3040);
												postincrement_rest195 =
													postincrement_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_postincrement_rest
														.add(postincrement_rest195
															.getTree());

												// AST REWRITE
												// elements: postincrement_rest, elementaccess
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 639:25: -> ^( PostIncrementExpression $elementaccess postincrement_rest )
													{
														// ../rsc/CSharp.g3:639:28: ^( PostIncrementExpression $elementaccess postincrement_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				PostIncrementExpression,
																				"PostIncrementExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_postincrement_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;

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

								pushFollow(FOLLOW_elementaccess_rest_in_elementaccess3062);
								elementaccess_rest196 = elementaccess_rest();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_elementaccess_rest
										.add(elementaccess_rest196.getTree());

								// AST REWRITE
								// elements: elementaccess, elementaccess_rest
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 641:23: -> ^( ElementAccess $elementaccess elementaccess_rest )
									{
										// ../rsc/CSharp.g3:641:26: ^( ElementAccess $elementaccess elementaccess_rest )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														ElementAccess,
														"ElementAccess"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_elementaccess_rest
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

						default :
							if (cnt36 >= 1)
								break loop36;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(36, this.input);
							throw eee;
					}
					cnt36++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "elementaccess"

	public static class elementaccess_rest_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "elementaccess_rest"
	// ../rsc/CSharp.g3:646:1: elementaccess_rest : lBRACKET expressionlist rBRACKET ;
	public final CSharpParser.elementaccess_rest_return elementaccess_rest()
			throws RecognitionException {
		CSharpParser.elementaccess_rest_return retval =
			new CSharpParser.elementaccess_rest_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACKET_return lBRACKET197 = null;

		CSharpParser.expressionlist_return expressionlist198 = null;

		CSharpParser.rBRACKET_return rBRACKET199 = null;

		try {
			// ../rsc/CSharp.g3:647:2: ( lBRACKET expressionlist rBRACKET )
			// ../rsc/CSharp.g3:647:4: lBRACKET expressionlist rBRACKET
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_lBRACKET_in_elementaccess_rest3090);
				lBRACKET197 = lBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, lBRACKET197.getTree());
				pushFollow(FOLLOW_expressionlist_in_elementaccess_rest3092);
				expressionlist198 = expressionlist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, expressionlist198.getTree());
				pushFollow(FOLLOW_rBRACKET_in_elementaccess_rest3094);
				rBRACKET199 = rBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, rBRACKET199.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "elementaccess_rest"

	public static class invocationexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "invocationexpression"
	// ../rsc/CSharp.g3:650:1: invocationexpression : ( primary_nonrec -> primary_nonrec ) ( ( postincrement_rest -> ^( PostIncrementExpression $invocationexpression postincrement_rest ) | postdecrement_rest -> ^( PostDecrementExpression $invocationexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $invocationexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $invocationexpression elementaccess_rest ) )* invocation_rest -> ^( InvocationExpression $invocationexpression invocation_rest ) )+ ;
	public final CSharpParser.invocationexpression_return invocationexpression()
			throws RecognitionException {
		CSharpParser.invocationexpression_return retval =
			new CSharpParser.invocationexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.primary_nonrec_return primary_nonrec200 = null;

		CSharpParser.postincrement_rest_return postincrement_rest201 = null;

		CSharpParser.postdecrement_rest_return postdecrement_rest202 = null;

		CSharpParser.memberaccess_rest_return memberaccess_rest203 = null;

		CSharpParser.elementaccess_rest_return elementaccess_rest204 = null;

		CSharpParser.invocation_rest_return invocation_rest205 = null;

		RewriteRuleSubtreeStream stream_invocation_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule invocation_rest");
		RewriteRuleSubtreeStream stream_postincrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postincrement_rest");
		RewriteRuleSubtreeStream stream_postdecrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postdecrement_rest");
		RewriteRuleSubtreeStream stream_memberaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule memberaccess_rest");
		RewriteRuleSubtreeStream stream_primary_nonrec =
			new RewriteRuleSubtreeStream(this.adaptor, "rule primary_nonrec");
		RewriteRuleSubtreeStream stream_elementaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule elementaccess_rest");
		try {
			// ../rsc/CSharp.g3:660:2: ( ( primary_nonrec -> primary_nonrec ) ( ( postincrement_rest -> ^( PostIncrementExpression $invocationexpression postincrement_rest ) | postdecrement_rest -> ^( PostDecrementExpression $invocationexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $invocationexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $invocationexpression elementaccess_rest ) )* invocation_rest -> ^( InvocationExpression $invocationexpression invocation_rest ) )+ )
			// ../rsc/CSharp.g3:660:4: ( primary_nonrec -> primary_nonrec ) ( ( postincrement_rest -> ^( PostIncrementExpression $invocationexpression postincrement_rest ) | postdecrement_rest -> ^( PostDecrementExpression $invocationexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $invocationexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $invocationexpression elementaccess_rest ) )* invocation_rest -> ^( InvocationExpression $invocationexpression invocation_rest ) )+
			{
				// ../rsc/CSharp.g3:660:4: ( primary_nonrec -> primary_nonrec )
				// ../rsc/CSharp.g3:660:5: primary_nonrec
				{
					pushFollow(FOLLOW_primary_nonrec_in_invocationexpression3112);
					primary_nonrec200 = primary_nonrec();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_primary_nonrec.add(primary_nonrec200.getTree());

					// AST REWRITE
					// elements: primary_nonrec
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 660:20: -> primary_nonrec
						{
							this.adaptor.addChild(
								root_0,
								stream_primary_nonrec.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:661:3: ( ( postincrement_rest -> ^( PostIncrementExpression $invocationexpression postincrement_rest ) | postdecrement_rest -> ^( PostDecrementExpression $invocationexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $invocationexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $invocationexpression elementaccess_rest ) )* invocation_rest -> ^( InvocationExpression $invocationexpression invocation_rest ) )+
				int cnt38 = 0;
				loop38: do {
					int alt38 = 2;
					int LA38_0 = this.input.LA(1);

					if ((LA38_0 == LBRACKET || LA38_0 == LPAREN
							|| LA38_0 == DOT || (LA38_0 >= INCREMENT && LA38_0 <= DECREMENT))) {
						alt38 = 1;
					}

					switch (alt38) {
						case 1 :
						// ../rsc/CSharp.g3:662:4: ( postincrement_rest -> ^( PostIncrementExpression $invocationexpression postincrement_rest ) | postdecrement_rest -> ^( PostDecrementExpression $invocationexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $invocationexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $invocationexpression elementaccess_rest ) )* invocation_rest
							{
								// ../rsc/CSharp.g3:662:4: ( postincrement_rest -> ^( PostIncrementExpression $invocationexpression postincrement_rest ) | postdecrement_rest -> ^( PostDecrementExpression $invocationexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $invocationexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $invocationexpression elementaccess_rest ) )*
								loop37: do {
									int alt37 = 5;
									switch (this.input.LA(1)) {
										case INCREMENT :
											{
												alt37 = 1;
											}
											break;
										case DECREMENT :
											{
												alt37 = 2;
											}
											break;
										case DOT :
											{
												alt37 = 3;
											}
											break;
										case LBRACKET :
											{
												alt37 = 4;
											}
											break;

									}

									switch (alt37) {
										case 1 :
										// ../rsc/CSharp.g3:663:5: postincrement_rest
											{
												pushFollow(FOLLOW_postincrement_rest_in_invocationexpression3132);
												postincrement_rest201 =
													postincrement_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_postincrement_rest
														.add(postincrement_rest201
															.getTree());

												// AST REWRITE
												// elements: invocationexpression, postincrement_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 663:24: -> ^( PostIncrementExpression $invocationexpression postincrement_rest )
													{
														// ../rsc/CSharp.g3:663:27: ^( PostIncrementExpression $invocationexpression postincrement_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				PostIncrementExpression,
																				"PostIncrementExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_postincrement_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 2 :
										// ../rsc/CSharp.g3:664:6: postdecrement_rest
											{
												pushFollow(FOLLOW_postdecrement_rest_in_invocationexpression3150);
												postdecrement_rest202 =
													postdecrement_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_postdecrement_rest
														.add(postdecrement_rest202
															.getTree());

												// AST REWRITE
												// elements: postdecrement_rest, invocationexpression
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 664:25: -> ^( PostDecrementExpression $invocationexpression postdecrement_rest )
													{
														// ../rsc/CSharp.g3:664:28: ^( PostDecrementExpression $invocationexpression postdecrement_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				PostDecrementExpression,
																				"PostDecrementExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_postdecrement_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 3 :
										// ../rsc/CSharp.g3:665:6: memberaccess_rest
											{
												pushFollow(FOLLOW_memberaccess_rest_in_invocationexpression3168);
												memberaccess_rest203 =
													memberaccess_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_memberaccess_rest
														.add(memberaccess_rest203
															.getTree());

												// AST REWRITE
												// elements: memberaccess_rest, invocationexpression
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 665:24: -> ^( MemberAccess $invocationexpression memberaccess_rest )
													{
														// ../rsc/CSharp.g3:665:27: ^( MemberAccess $invocationexpression memberaccess_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				MemberAccess,
																				"MemberAccess"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_memberaccess_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 4 :
										// ../rsc/CSharp.g3:666:6: elementaccess_rest
											{
												pushFollow(FOLLOW_elementaccess_rest_in_invocationexpression3186);
												elementaccess_rest204 =
													elementaccess_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_elementaccess_rest
														.add(elementaccess_rest204
															.getTree());

												// AST REWRITE
												// elements: elementaccess_rest, invocationexpression
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 666:25: -> ^( ElementAccess $invocationexpression elementaccess_rest )
													{
														// ../rsc/CSharp.g3:666:28: ^( ElementAccess $invocationexpression elementaccess_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				ElementAccess,
																				"ElementAccess"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_elementaccess_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;

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

								pushFollow(FOLLOW_invocation_rest_in_invocationexpression3208);
								invocation_rest205 = invocation_rest();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_invocation_rest
										.add(invocation_rest205.getTree());

								// AST REWRITE
								// elements: invocationexpression, invocation_rest
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 668:20: -> ^( InvocationExpression $invocationexpression invocation_rest )
									{
										// ../rsc/CSharp.g3:668:23: ^( InvocationExpression $invocationexpression invocation_rest )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor
													.becomeRoot(
														(Object) this.adaptor
															.create(
																InvocationExpression,
																"InvocationExpression"),
														root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_invocation_rest
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

						default :
							if (cnt38 >= 1)
								break loop38;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(38, this.input);
							throw eee;
					}
					cnt38++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "invocationexpression"

	public static class invocation_rest_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "invocation_rest"
	// ../rsc/CSharp.g3:673:1: invocation_rest : lPAREN ( argumentlist )? rPAREN ;
	public final CSharpParser.invocation_rest_return invocation_rest()
			throws RecognitionException {
		CSharpParser.invocation_rest_return retval =
			new CSharpParser.invocation_rest_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lPAREN_return lPAREN206 = null;

		CSharpParser.argumentlist_return argumentlist207 = null;

		CSharpParser.rPAREN_return rPAREN208 = null;

		try {
			// ../rsc/CSharp.g3:674:2: ( lPAREN ( argumentlist )? rPAREN )
			// ../rsc/CSharp.g3:674:5: lPAREN ( argumentlist )? rPAREN
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_lPAREN_in_invocation_rest3237);
				lPAREN206 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, lPAREN206.getTree());
				// ../rsc/CSharp.g3:674:12: ( argumentlist )?
				int alt39 = 2;
				int LA39_0 = this.input.LA(1);

				if ((LA39_0 == LPAREN || (LA39_0 >= PLUS && LA39_0 <= MINUS)
						|| (LA39_0 >= EXCLAM && LA39_0 <= TILDE)
						|| (LA39_0 >= INCREMENT && LA39_0 <= DECREMENT)
						|| (LA39_0 >= BASE && LA39_0 <= BOOL) || LA39_0 == BYTE
						|| (LA39_0 >= CHAR && LA39_0 <= CHECKED)
						|| (LA39_0 >= DECIMAL && LA39_0 <= DELEGATE)
						|| LA39_0 == DOUBLE || LA39_0 == FALSE
						|| LA39_0 == FLOAT || LA39_0 == INT || LA39_0 == LONG
						|| (LA39_0 >= NEW && LA39_0 <= OBJECT) || LA39_0 == OUT
						|| LA39_0 == REF || LA39_0 == SBYTE || LA39_0 == SHORT
						|| LA39_0 == STRING || LA39_0 == THIS || LA39_0 == TRUE
						|| (LA39_0 >= TYPEOF && LA39_0 <= UNCHECKED)
						|| LA39_0 == USHORT || (LA39_0 >= ADD && LA39_0 <= Stringliteral))) {
					alt39 = 1;
				}
				switch (alt39) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: argumentlist
						{
							pushFollow(FOLLOW_argumentlist_in_invocation_rest3239);
							argumentlist207 = argumentlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								this.adaptor.addChild(
									root_0,
									argumentlist207.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_invocation_rest3242);
				rPAREN208 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, rPAREN208.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "invocation_rest"

	public static class postincrementexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "postincrementexpression"
	// ../rsc/CSharp.g3:677:1: postincrementexpression : ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $postincrementexpression invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $postincrementexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $postincrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postincrementexpression elementaccess_rest ) )* postincrement_rest -> ^( PostIncrementExpression $postincrementexpression postincrement_rest ) )+ ;
	public final CSharpParser.postincrementexpression_return postincrementexpression()
			throws RecognitionException {
		CSharpParser.postincrementexpression_return retval =
			new CSharpParser.postincrementexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.primary_nonrec_return primary_nonrec209 = null;

		CSharpParser.invocation_rest_return invocation_rest210 = null;

		CSharpParser.postdecrement_rest_return postdecrement_rest211 = null;

		CSharpParser.memberaccess_rest_return memberaccess_rest212 = null;

		CSharpParser.elementaccess_rest_return elementaccess_rest213 = null;

		CSharpParser.postincrement_rest_return postincrement_rest214 = null;

		RewriteRuleSubtreeStream stream_invocation_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule invocation_rest");
		RewriteRuleSubtreeStream stream_postincrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postincrement_rest");
		RewriteRuleSubtreeStream stream_postdecrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postdecrement_rest");
		RewriteRuleSubtreeStream stream_memberaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule memberaccess_rest");
		RewriteRuleSubtreeStream stream_primary_nonrec =
			new RewriteRuleSubtreeStream(this.adaptor, "rule primary_nonrec");
		RewriteRuleSubtreeStream stream_elementaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule elementaccess_rest");
		try {
			// ../rsc/CSharp.g3:687:2: ( ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $postincrementexpression invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $postincrementexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $postincrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postincrementexpression elementaccess_rest ) )* postincrement_rest -> ^( PostIncrementExpression $postincrementexpression postincrement_rest ) )+ )
			// ../rsc/CSharp.g3:687:4: ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $postincrementexpression invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $postincrementexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $postincrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postincrementexpression elementaccess_rest ) )* postincrement_rest -> ^( PostIncrementExpression $postincrementexpression postincrement_rest ) )+
			{
				// ../rsc/CSharp.g3:687:4: ( primary_nonrec -> primary_nonrec )
				// ../rsc/CSharp.g3:687:5: primary_nonrec
				{
					pushFollow(FOLLOW_primary_nonrec_in_postincrementexpression3260);
					primary_nonrec209 = primary_nonrec();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_primary_nonrec.add(primary_nonrec209.getTree());

					// AST REWRITE
					// elements: primary_nonrec
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 687:20: -> primary_nonrec
						{
							this.adaptor.addChild(
								root_0,
								stream_primary_nonrec.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:688:3: ( ( invocation_rest -> ^( InvocationExpression $postincrementexpression invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $postincrementexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $postincrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postincrementexpression elementaccess_rest ) )* postincrement_rest -> ^( PostIncrementExpression $postincrementexpression postincrement_rest ) )+
				int cnt41 = 0;
				loop41: do {
					int alt41 = 2;
					int LA41_0 = this.input.LA(1);

					if ((LA41_0 == LBRACKET || LA41_0 == LPAREN
							|| LA41_0 == DOT || (LA41_0 >= INCREMENT && LA41_0 <= DECREMENT))) {
						alt41 = 1;
					}

					switch (alt41) {
						case 1 :
						// ../rsc/CSharp.g3:689:4: ( invocation_rest -> ^( InvocationExpression $postincrementexpression invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $postincrementexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $postincrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postincrementexpression elementaccess_rest ) )* postincrement_rest
							{
								// ../rsc/CSharp.g3:689:4: ( invocation_rest -> ^( InvocationExpression $postincrementexpression invocation_rest ) | postdecrement_rest -> ^( PostDecrementExpression $postincrementexpression postdecrement_rest ) | memberaccess_rest -> ^( MemberAccess $postincrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postincrementexpression elementaccess_rest ) )*
								loop40: do {
									int alt40 = 5;
									switch (this.input.LA(1)) {
										case LPAREN :
											{
												alt40 = 1;
											}
											break;
										case DECREMENT :
											{
												alt40 = 2;
											}
											break;
										case DOT :
											{
												alt40 = 3;
											}
											break;
										case LBRACKET :
											{
												alt40 = 4;
											}
											break;

									}

									switch (alt40) {
										case 1 :
										// ../rsc/CSharp.g3:690:5: invocation_rest
											{
												pushFollow(FOLLOW_invocation_rest_in_postincrementexpression3280);
												invocation_rest210 =
													invocation_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_invocation_rest
														.add(invocation_rest210
															.getTree());

												// AST REWRITE
												// elements: invocation_rest, postincrementexpression
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 690:21: -> ^( InvocationExpression $postincrementexpression invocation_rest )
													{
														// ../rsc/CSharp.g3:690:24: ^( InvocationExpression $postincrementexpression invocation_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				InvocationExpression,
																				"InvocationExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_invocation_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 2 :
										// ../rsc/CSharp.g3:691:6: postdecrement_rest
											{
												pushFollow(FOLLOW_postdecrement_rest_in_postincrementexpression3298);
												postdecrement_rest211 =
													postdecrement_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_postdecrement_rest
														.add(postdecrement_rest211
															.getTree());

												// AST REWRITE
												// elements: postdecrement_rest, postincrementexpression
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 691:25: -> ^( PostDecrementExpression $postincrementexpression postdecrement_rest )
													{
														// ../rsc/CSharp.g3:691:28: ^( PostDecrementExpression $postincrementexpression postdecrement_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				PostDecrementExpression,
																				"PostDecrementExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_postdecrement_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 3 :
										// ../rsc/CSharp.g3:692:6: memberaccess_rest
											{
												pushFollow(FOLLOW_memberaccess_rest_in_postincrementexpression3316);
												memberaccess_rest212 =
													memberaccess_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_memberaccess_rest
														.add(memberaccess_rest212
															.getTree());

												// AST REWRITE
												// elements: memberaccess_rest, postincrementexpression
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 692:24: -> ^( MemberAccess $postincrementexpression memberaccess_rest )
													{
														// ../rsc/CSharp.g3:692:27: ^( MemberAccess $postincrementexpression memberaccess_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				MemberAccess,
																				"MemberAccess"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_memberaccess_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 4 :
										// ../rsc/CSharp.g3:693:6: elementaccess_rest
											{
												pushFollow(FOLLOW_elementaccess_rest_in_postincrementexpression3334);
												elementaccess_rest213 =
													elementaccess_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_elementaccess_rest
														.add(elementaccess_rest213
															.getTree());

												// AST REWRITE
												// elements: postincrementexpression, elementaccess_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 693:25: -> ^( ElementAccess $postincrementexpression elementaccess_rest )
													{
														// ../rsc/CSharp.g3:693:28: ^( ElementAccess $postincrementexpression elementaccess_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				ElementAccess,
																				"ElementAccess"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_elementaccess_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;

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

								pushFollow(FOLLOW_postincrement_rest_in_postincrementexpression3356);
								postincrement_rest214 = postincrement_rest();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_postincrement_rest
										.add(postincrement_rest214.getTree());

								// AST REWRITE
								// elements: postincrement_rest, postincrementexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 695:23: -> ^( PostIncrementExpression $postincrementexpression postincrement_rest )
									{
										// ../rsc/CSharp.g3:695:26: ^( PostIncrementExpression $postincrementexpression postincrement_rest )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor
													.becomeRoot(
														(Object) this.adaptor
															.create(
																PostIncrementExpression,
																"PostIncrementExpression"),
														root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_postincrement_rest
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

						default :
							if (cnt41 >= 1)
								break loop41;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(41, this.input);
							throw eee;
					}
					cnt41++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "postincrementexpression"

	public static class postincrement_rest_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "postincrement_rest"
	// ../rsc/CSharp.g3:700:1: postincrement_rest : iNCREMENT ;
	public final CSharpParser.postincrement_rest_return postincrement_rest()
			throws RecognitionException {
		CSharpParser.postincrement_rest_return retval =
			new CSharpParser.postincrement_rest_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.iNCREMENT_return iNCREMENT215 = null;

		try {
			// ../rsc/CSharp.g3:701:2: ( iNCREMENT )
			// ../rsc/CSharp.g3:701:4: iNCREMENT
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_iNCREMENT_in_postincrement_rest3384);
				iNCREMENT215 = iNCREMENT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, iNCREMENT215.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "postincrement_rest"

	public static class postdecrementexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "postdecrementexpression"
	// ../rsc/CSharp.g3:704:1: postdecrementexpression : ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $postdecrementexpression invocation_rest ) | postincrement_rest -> ^( PostIncrementExpression $postdecrementexpression postincrement_rest ) | memberaccess_rest -> ^( MemberAccess $postdecrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postdecrementexpression elementaccess_rest ) )* postdecrement_rest -> ^( PostDecrementExpression $postdecrementexpression postdecrement_rest ) )+ ;
	public final CSharpParser.postdecrementexpression_return postdecrementexpression()
			throws RecognitionException {
		CSharpParser.postdecrementexpression_return retval =
			new CSharpParser.postdecrementexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.primary_nonrec_return primary_nonrec216 = null;

		CSharpParser.invocation_rest_return invocation_rest217 = null;

		CSharpParser.postincrement_rest_return postincrement_rest218 = null;

		CSharpParser.memberaccess_rest_return memberaccess_rest219 = null;

		CSharpParser.elementaccess_rest_return elementaccess_rest220 = null;

		CSharpParser.postdecrement_rest_return postdecrement_rest221 = null;

		RewriteRuleSubtreeStream stream_invocation_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule invocation_rest");
		RewriteRuleSubtreeStream stream_postincrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postincrement_rest");
		RewriteRuleSubtreeStream stream_memberaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule memberaccess_rest");
		RewriteRuleSubtreeStream stream_postdecrement_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule postdecrement_rest");
		RewriteRuleSubtreeStream stream_primary_nonrec =
			new RewriteRuleSubtreeStream(this.adaptor, "rule primary_nonrec");
		RewriteRuleSubtreeStream stream_elementaccess_rest =
			new RewriteRuleSubtreeStream(this.adaptor, "rule elementaccess_rest");
		try {
			// ../rsc/CSharp.g3:705:2: ( ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $postdecrementexpression invocation_rest ) | postincrement_rest -> ^( PostIncrementExpression $postdecrementexpression postincrement_rest ) | memberaccess_rest -> ^( MemberAccess $postdecrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postdecrementexpression elementaccess_rest ) )* postdecrement_rest -> ^( PostDecrementExpression $postdecrementexpression postdecrement_rest ) )+ )
			// ../rsc/CSharp.g3:705:4: ( primary_nonrec -> primary_nonrec ) ( ( invocation_rest -> ^( InvocationExpression $postdecrementexpression invocation_rest ) | postincrement_rest -> ^( PostIncrementExpression $postdecrementexpression postincrement_rest ) | memberaccess_rest -> ^( MemberAccess $postdecrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postdecrementexpression elementaccess_rest ) )* postdecrement_rest -> ^( PostDecrementExpression $postdecrementexpression postdecrement_rest ) )+
			{
				// ../rsc/CSharp.g3:705:4: ( primary_nonrec -> primary_nonrec )
				// ../rsc/CSharp.g3:705:5: primary_nonrec
				{
					pushFollow(FOLLOW_primary_nonrec_in_postdecrementexpression3396);
					primary_nonrec216 = primary_nonrec();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_primary_nonrec.add(primary_nonrec216.getTree());

					// AST REWRITE
					// elements: primary_nonrec
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 705:20: -> primary_nonrec
						{
							this.adaptor.addChild(
								root_0,
								stream_primary_nonrec.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:706:3: ( ( invocation_rest -> ^( InvocationExpression $postdecrementexpression invocation_rest ) | postincrement_rest -> ^( PostIncrementExpression $postdecrementexpression postincrement_rest ) | memberaccess_rest -> ^( MemberAccess $postdecrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postdecrementexpression elementaccess_rest ) )* postdecrement_rest -> ^( PostDecrementExpression $postdecrementexpression postdecrement_rest ) )+
				int cnt43 = 0;
				loop43: do {
					int alt43 = 2;
					int LA43_0 = this.input.LA(1);

					if ((LA43_0 == LBRACKET || LA43_0 == LPAREN
							|| LA43_0 == DOT || (LA43_0 >= INCREMENT && LA43_0 <= DECREMENT))) {
						alt43 = 1;
					}

					switch (alt43) {
						case 1 :
						// ../rsc/CSharp.g3:707:4: ( invocation_rest -> ^( InvocationExpression $postdecrementexpression invocation_rest ) | postincrement_rest -> ^( PostIncrementExpression $postdecrementexpression postincrement_rest ) | memberaccess_rest -> ^( MemberAccess $postdecrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postdecrementexpression elementaccess_rest ) )* postdecrement_rest
							{
								// ../rsc/CSharp.g3:707:4: ( invocation_rest -> ^( InvocationExpression $postdecrementexpression invocation_rest ) | postincrement_rest -> ^( PostIncrementExpression $postdecrementexpression postincrement_rest ) | memberaccess_rest -> ^( MemberAccess $postdecrementexpression memberaccess_rest ) | elementaccess_rest -> ^( ElementAccess $postdecrementexpression elementaccess_rest ) )*
								loop42: do {
									int alt42 = 5;
									switch (this.input.LA(1)) {
										case LPAREN :
											{
												alt42 = 1;
											}
											break;
										case INCREMENT :
											{
												alt42 = 2;
											}
											break;
										case DOT :
											{
												alt42 = 3;
											}
											break;
										case LBRACKET :
											{
												alt42 = 4;
											}
											break;

									}

									switch (alt42) {
										case 1 :
										// ../rsc/CSharp.g3:708:5: invocation_rest
											{
												pushFollow(FOLLOW_invocation_rest_in_postdecrementexpression3416);
												invocation_rest217 =
													invocation_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_invocation_rest
														.add(invocation_rest217
															.getTree());

												// AST REWRITE
												// elements: postdecrementexpression, invocation_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 708:21: -> ^( InvocationExpression $postdecrementexpression invocation_rest )
													{
														// ../rsc/CSharp.g3:708:24: ^( InvocationExpression $postdecrementexpression invocation_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				InvocationExpression,
																				"InvocationExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_invocation_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 2 :
										// ../rsc/CSharp.g3:709:6: postincrement_rest
											{
												pushFollow(FOLLOW_postincrement_rest_in_postdecrementexpression3434);
												postincrement_rest218 =
													postincrement_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_postincrement_rest
														.add(postincrement_rest218
															.getTree());

												// AST REWRITE
												// elements: postdecrementexpression, postincrement_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 709:25: -> ^( PostIncrementExpression $postdecrementexpression postincrement_rest )
													{
														// ../rsc/CSharp.g3:709:28: ^( PostIncrementExpression $postdecrementexpression postincrement_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				PostIncrementExpression,
																				"PostIncrementExpression"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_postincrement_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 3 :
										// ../rsc/CSharp.g3:710:6: memberaccess_rest
											{
												pushFollow(FOLLOW_memberaccess_rest_in_postdecrementexpression3452);
												memberaccess_rest219 =
													memberaccess_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_memberaccess_rest
														.add(memberaccess_rest219
															.getTree());

												// AST REWRITE
												// elements: postdecrementexpression, memberaccess_rest
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 710:24: -> ^( MemberAccess $postdecrementexpression memberaccess_rest )
													{
														// ../rsc/CSharp.g3:710:27: ^( MemberAccess $postdecrementexpression memberaccess_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				MemberAccess,
																				"MemberAccess"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_memberaccess_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;
										case 4 :
										// ../rsc/CSharp.g3:711:6: elementaccess_rest
											{
												pushFollow(FOLLOW_elementaccess_rest_in_postdecrementexpression3470);
												elementaccess_rest220 =
													elementaccess_rest();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_elementaccess_rest
														.add(elementaccess_rest220
															.getTree());

												// AST REWRITE
												// elements: elementaccess_rest, postdecrementexpression
												// token labels: 
												// rule labels: retval
												// token list labels: 
												// rule list labels: 
												// wildcard labels: 
												if (this.state.backtracking == 0) {
													retval.tree = root_0;
													RewriteRuleSubtreeStream stream_retval =
														new RewriteRuleSubtreeStream(
															this.adaptor,
															"rule retval",
															retval != null ? retval.tree
																	: null);

													root_0 =
														(Object) this.adaptor.nil();
													// 711:25: -> ^( ElementAccess $postdecrementexpression elementaccess_rest )
													{
														// ../rsc/CSharp.g3:711:28: ^( ElementAccess $postdecrementexpression elementaccess_rest )
														{
															Object root_1 =
																(Object) this.adaptor
																	.nil();
															root_1 =
																(Object) this.adaptor
																	.becomeRoot(
																		(Object) this.adaptor
																			.create(
																				ElementAccess,
																				"ElementAccess"),
																		root_1);

															this.adaptor
																.addChild(
																	root_1,
																	stream_retval
																		.nextTree());
															this.adaptor
																.addChild(
																	root_1,
																	stream_elementaccess_rest
																		.nextTree());

															this.adaptor.addChild(
																root_0,
																root_1);
														}

													}

													retval.tree = root_0;
												}
											}
											break;

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

								pushFollow(FOLLOW_postdecrement_rest_in_postdecrementexpression3492);
								postdecrement_rest221 = postdecrement_rest();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_postdecrement_rest
										.add(postdecrement_rest221.getTree());

								// AST REWRITE
								// elements: postdecrement_rest, postdecrementexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 713:23: -> ^( PostDecrementExpression $postdecrementexpression postdecrement_rest )
									{
										// ../rsc/CSharp.g3:713:26: ^( PostDecrementExpression $postdecrementexpression postdecrement_rest )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor
													.becomeRoot(
														(Object) this.adaptor
															.create(
																PostDecrementExpression,
																"PostDecrementExpression"),
														root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_postdecrement_rest
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

						default :
							if (cnt43 >= 1)
								break loop43;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(43, this.input);
							throw eee;
					}
					cnt43++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "postdecrementexpression"

	public static class postdecrement_rest_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "postdecrement_rest"
	// ../rsc/CSharp.g3:717:1: postdecrement_rest : dECREMENT ;
	public final CSharpParser.postdecrement_rest_return postdecrement_rest()
			throws RecognitionException {
		CSharpParser.postdecrement_rest_return retval =
			new CSharpParser.postdecrement_rest_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.dECREMENT_return dECREMENT222 = null;

		try {
			// ../rsc/CSharp.g3:718:2: ( dECREMENT )
			// ../rsc/CSharp.g3:718:4: dECREMENT
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_dECREMENT_in_postdecrement_rest3519);
				dECREMENT222 = dECREMENT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, dECREMENT222.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "postdecrement_rest"

	public static class simplename_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "simplename"
	// ../rsc/CSharp.g3:722:1: simplename : identifier ( typeargumentlist )? -> ^( SimpleName identifier ( typeargumentlist )? ) ;
	public final CSharpParser.simplename_return simplename()
			throws RecognitionException {
		CSharpParser.simplename_return retval =
			new CSharpParser.simplename_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier223 = null;

		CSharpParser.typeargumentlist_return typeargumentlist224 = null;

		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_typeargumentlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeargumentlist");
		try {
			// ../rsc/CSharp.g3:723:5: ( identifier ( typeargumentlist )? -> ^( SimpleName identifier ( typeargumentlist )? ) )
			// ../rsc/CSharp.g3:723:9: identifier ( typeargumentlist )?
			{
				pushFollow(FOLLOW_identifier_in_simplename3536);
				identifier223 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier223.getTree());
				// ../rsc/CSharp.g3:723:20: ( typeargumentlist )?
				int alt44 = 2;
				alt44 = this.dfa44.predict(this.input);
				switch (alt44) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeargumentlist
						{
							pushFollow(FOLLOW_typeargumentlist_in_simplename3538);
							typeargumentlist224 = typeargumentlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeargumentlist.add(typeargumentlist224
									.getTree());

						}
						break;

				}

				// AST REWRITE
				// elements: typeargumentlist, identifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 724:5: -> ^( SimpleName identifier ( typeargumentlist )? )
					{
						// ../rsc/CSharp.g3:724:9: ^( SimpleName identifier ( typeargumentlist )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(SimpleName, "SimpleName"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:724:33: ( typeargumentlist )?
							if (stream_typeargumentlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeargumentlist.nextTree());

							}
							stream_typeargumentlist.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "simplename"

	public static class parenthesizedexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "parenthesizedexpression"
	// ../rsc/CSharp.g3:727:1: parenthesizedexpression : lPAREN expression rPAREN -> ^( ParenthesizedExpression lPAREN expression rPAREN ) ;
	public final CSharpParser.parenthesizedexpression_return parenthesizedexpression()
			throws RecognitionException {
		CSharpParser.parenthesizedexpression_return retval =
			new CSharpParser.parenthesizedexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lPAREN_return lPAREN225 = null;

		CSharpParser.expression_return expression226 = null;

		CSharpParser.rPAREN_return rPAREN227 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		try {
			// ../rsc/CSharp.g3:728:5: ( lPAREN expression rPAREN -> ^( ParenthesizedExpression lPAREN expression rPAREN ) )
			// ../rsc/CSharp.g3:728:9: lPAREN expression rPAREN
			{
				pushFollow(FOLLOW_lPAREN_in_parenthesizedexpression3574);
				lPAREN225 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN225.getTree());
				pushFollow(FOLLOW_expression_in_parenthesizedexpression3576);
				expression226 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression226.getTree());
				pushFollow(FOLLOW_rPAREN_in_parenthesizedexpression3578);
				rPAREN227 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN227.getTree());

				// AST REWRITE
				// elements: expression, lPAREN, rPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 729:5: -> ^( ParenthesizedExpression lPAREN expression rPAREN )
					{
						// ../rsc/CSharp.g3:729:8: ^( ParenthesizedExpression lPAREN expression rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ParenthesizedExpression,
										"ParenthesizedExpression"), root_1);

							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "parenthesizedexpression"

	public static class predefinedtype_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "predefinedtype"
	// ../rsc/CSharp.g3:734:1: predefinedtype : ( bOOL | bYTE | cHAR | dECIMAL | dOUBLE | fLOAT | iNT | lONG | oBJECT | sBYTE | sHORT | sTRING | uINT | uLONG | uSHORT );
	public final CSharpParser.predefinedtype_return predefinedtype()
			throws RecognitionException {
		CSharpParser.predefinedtype_return retval =
			new CSharpParser.predefinedtype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.bOOL_return bOOL228 = null;

		CSharpParser.bYTE_return bYTE229 = null;

		CSharpParser.cHAR_return cHAR230 = null;

		CSharpParser.dECIMAL_return dECIMAL231 = null;

		CSharpParser.dOUBLE_return dOUBLE232 = null;

		CSharpParser.fLOAT_return fLOAT233 = null;

		CSharpParser.iNT_return iNT234 = null;

		CSharpParser.lONG_return lONG235 = null;

		CSharpParser.oBJECT_return oBJECT236 = null;

		CSharpParser.sBYTE_return sBYTE237 = null;

		CSharpParser.sHORT_return sHORT238 = null;

		CSharpParser.sTRING_return sTRING239 = null;

		CSharpParser.uINT_return uINT240 = null;

		CSharpParser.uLONG_return uLONG241 = null;

		CSharpParser.uSHORT_return uSHORT242 = null;

		try {
			// ../rsc/CSharp.g3:735:5: ( bOOL | bYTE | cHAR | dECIMAL | dOUBLE | fLOAT | iNT | lONG | oBJECT | sBYTE | sHORT | sTRING | uINT | uLONG | uSHORT )
			int alt45 = 15;
			alt45 = this.dfa45.predict(this.input);
			switch (alt45) {
				case 1 :
				// ../rsc/CSharp.g3:735:10: bOOL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bOOL_in_predefinedtype3616);
						bOOL228 = bOOL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bOOL228.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:735:17: bYTE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bYTE_in_predefinedtype3620);
						bYTE229 = bYTE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bYTE229.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:735:24: cHAR
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_cHAR_in_predefinedtype3624);
						cHAR230 = cHAR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cHAR230.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:735:31: dECIMAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dECIMAL_in_predefinedtype3628);
						dECIMAL231 = dECIMAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dECIMAL231.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:735:41: dOUBLE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dOUBLE_in_predefinedtype3632);
						dOUBLE232 = dOUBLE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dOUBLE232.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:735:50: fLOAT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fLOAT_in_predefinedtype3636);
						fLOAT233 = fLOAT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fLOAT233.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:735:58: iNT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNT_in_predefinedtype3640);
						iNT234 = iNT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNT234.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:735:64: lONG
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lONG_in_predefinedtype3644);
						lONG235 = lONG();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, lONG235.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:736:10: oBJECT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oBJECT_in_predefinedtype3655);
						oBJECT236 = oBJECT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oBJECT236.getTree());

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:736:19: sBYTE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sBYTE_in_predefinedtype3659);
						sBYTE237 = sBYTE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sBYTE237.getTree());

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:736:27: sHORT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sHORT_in_predefinedtype3663);
						sHORT238 = sHORT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sHORT238.getTree());

					}
					break;
				case 12 :
				// ../rsc/CSharp.g3:736:35: sTRING
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTRING_in_predefinedtype3667);
						sTRING239 = sTRING();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTRING239.getTree());

					}
					break;
				case 13 :
				// ../rsc/CSharp.g3:736:44: uINT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uINT_in_predefinedtype3671);
						uINT240 = uINT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uINT240.getTree());

					}
					break;
				case 14 :
				// ../rsc/CSharp.g3:736:51: uLONG
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uLONG_in_predefinedtype3675);
						uLONG241 = uLONG();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uLONG241.getTree());

					}
					break;
				case 15 :
				// ../rsc/CSharp.g3:736:59: uSHORT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uSHORT_in_predefinedtype3679);
						uSHORT242 = uSHORT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, uSHORT242.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "predefinedtype"

	public static class expressionlist_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "expressionlist"
	// ../rsc/CSharp.g3:741:1: expressionlist : expression ( cOMMA expression )* -> ^( ExpressionList expression ( cOMMA expression )* ) ;
	public final CSharpParser.expressionlist_return expressionlist()
			throws RecognitionException {
		CSharpParser.expressionlist_return retval =
			new CSharpParser.expressionlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.expression_return expression243 = null;

		CSharpParser.cOMMA_return cOMMA244 = null;

		CSharpParser.expression_return expression245 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		try {
			// ../rsc/CSharp.g3:742:5: ( expression ( cOMMA expression )* -> ^( ExpressionList expression ( cOMMA expression )* ) )
			// ../rsc/CSharp.g3:742:9: expression ( cOMMA expression )*
			{
				pushFollow(FOLLOW_expression_in_expressionlist3704);
				expression243 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression243.getTree());
				// ../rsc/CSharp.g3:742:20: ( cOMMA expression )*
				loop46: do {
					int alt46 = 2;
					int LA46_0 = this.input.LA(1);

					if ((LA46_0 == COMMA)) {
						alt46 = 1;
					}

					switch (alt46) {
						case 1 :
						// ../rsc/CSharp.g3:742:21: cOMMA expression
							{
								pushFollow(FOLLOW_cOMMA_in_expressionlist3707);
								cOMMA244 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_cOMMA.add(cOMMA244.getTree());
								pushFollow(FOLLOW_expression_in_expressionlist3709);
								expression245 = expression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_expression.add(expression245
										.getTree());

							}
							break;

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

				// AST REWRITE
				// elements: expression, cOMMA, expression
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 743:5: -> ^( ExpressionList expression ( cOMMA expression )* )
					{
						// ../rsc/CSharp.g3:743:8: ^( ExpressionList expression ( cOMMA expression )* )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ExpressionList,
										"ExpressionList"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());
							// ../rsc/CSharp.g3:743:36: ( cOMMA expression )*
							while (stream_cOMMA.hasNext()
									|| stream_expression.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_cOMMA.nextTree());
								this.adaptor.addChild(
									root_1,
									stream_expression.nextTree());

							}
							stream_cOMMA.reset();
							stream_expression.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "expressionlist"

	public static class thisaccess_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "thisaccess"
	// ../rsc/CSharp.g3:746:1: thisaccess : tHIS -> ^( ThisAccess tHIS ) ;
	public final CSharpParser.thisaccess_return thisaccess()
			throws RecognitionException {
		CSharpParser.thisaccess_return retval =
			new CSharpParser.thisaccess_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.tHIS_return tHIS246 = null;

		RewriteRuleSubtreeStream stream_tHIS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule tHIS");
		try {
			// ../rsc/CSharp.g3:747:5: ( tHIS -> ^( ThisAccess tHIS ) )
			// ../rsc/CSharp.g3:747:9: tHIS
			{
				pushFollow(FOLLOW_tHIS_in_thisaccess3749);
				tHIS246 = tHIS();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_tHIS.add(tHIS246.getTree());

				// AST REWRITE
				// elements: tHIS
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 748:5: -> ^( ThisAccess tHIS )
					{
						// ../rsc/CSharp.g3:748:8: ^( ThisAccess tHIS )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(ThisAccess, "ThisAccess"), root_1);

							this.adaptor.addChild(root_1, stream_tHIS.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "thisaccess"

	public static class baseaccess_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "baseaccess"
	// ../rsc/CSharp.g3:751:1: baseaccess : ( bASE dOT identifier ( typeargumentlist )? -> ^( BaseAccess bASE dOT identifier ( typeargumentlist )? ) | bASE lBRACKET expressionlist rBRACKET -> ^( BaseAccess bASE lBRACKET expressionlist rBRACKET ) );
	public final CSharpParser.baseaccess_return baseaccess()
			throws RecognitionException {
		CSharpParser.baseaccess_return retval =
			new CSharpParser.baseaccess_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.bASE_return bASE247 = null;

		CSharpParser.dOT_return dOT248 = null;

		CSharpParser.identifier_return identifier249 = null;

		CSharpParser.typeargumentlist_return typeargumentlist250 = null;

		CSharpParser.bASE_return bASE251 = null;

		CSharpParser.lBRACKET_return lBRACKET252 = null;

		CSharpParser.expressionlist_return expressionlist253 = null;

		CSharpParser.rBRACKET_return rBRACKET254 = null;

		RewriteRuleSubtreeStream stream_lBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACKET");
		RewriteRuleSubtreeStream stream_expressionlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expressionlist");
		RewriteRuleSubtreeStream stream_dOT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dOT");
		RewriteRuleSubtreeStream stream_rBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACKET");
		RewriteRuleSubtreeStream stream_bASE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule bASE");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_typeargumentlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeargumentlist");
		try {
			// ../rsc/CSharp.g3:752:5: ( bASE dOT identifier ( typeargumentlist )? -> ^( BaseAccess bASE dOT identifier ( typeargumentlist )? ) | bASE lBRACKET expressionlist rBRACKET -> ^( BaseAccess bASE lBRACKET expressionlist rBRACKET ) )
			int alt48 = 2;
			alt48 = this.dfa48.predict(this.input);
			switch (alt48) {
				case 1 :
				// ../rsc/CSharp.g3:752:9: bASE dOT identifier ( typeargumentlist )?
					{
						pushFollow(FOLLOW_bASE_in_baseaccess3780);
						bASE247 = bASE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_bASE.add(bASE247.getTree());
						pushFollow(FOLLOW_dOT_in_baseaccess3782);
						dOT248 = dOT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_dOT.add(dOT248.getTree());
						pushFollow(FOLLOW_identifier_in_baseaccess3784);
						identifier249 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier249.getTree());
						// ../rsc/CSharp.g3:752:29: ( typeargumentlist )?
						int alt47 = 2;
						alt47 = this.dfa47.predict(this.input);
						switch (alt47) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: typeargumentlist
								{
									pushFollow(FOLLOW_typeargumentlist_in_baseaccess3786);
									typeargumentlist250 = typeargumentlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_typeargumentlist
											.add(typeargumentlist250.getTree());

								}
								break;

						}

						// AST REWRITE
						// elements: identifier, dOT, bASE, typeargumentlist
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 753:5: -> ^( BaseAccess bASE dOT identifier ( typeargumentlist )? )
							{
								// ../rsc/CSharp.g3:753:8: ^( BaseAccess bASE dOT identifier ( typeargumentlist )? )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												BaseAccess,
												"BaseAccess"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_bASE.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_dOT.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());
									// ../rsc/CSharp.g3:753:41: ( typeargumentlist )?
									if (stream_typeargumentlist.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_typeargumentlist.nextTree());

									}
									stream_typeargumentlist.reset();

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:754:9: bASE lBRACKET expressionlist rBRACKET
					{
						pushFollow(FOLLOW_bASE_in_baseaccess3816);
						bASE251 = bASE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_bASE.add(bASE251.getTree());
						pushFollow(FOLLOW_lBRACKET_in_baseaccess3818);
						lBRACKET252 = lBRACKET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACKET.add(lBRACKET252.getTree());
						pushFollow(FOLLOW_expressionlist_in_baseaccess3820);
						expressionlist253 = expressionlist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_expressionlist.add(expressionlist253
								.getTree());
						pushFollow(FOLLOW_rBRACKET_in_baseaccess3822);
						rBRACKET254 = rBRACKET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACKET.add(rBRACKET254.getTree());

						// AST REWRITE
						// elements: expressionlist, rBRACKET, lBRACKET, bASE
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 755:5: -> ^( BaseAccess bASE lBRACKET expressionlist rBRACKET )
							{
								// ../rsc/CSharp.g3:755:8: ^( BaseAccess bASE lBRACKET expressionlist rBRACKET )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												BaseAccess,
												"BaseAccess"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_bASE.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lBRACKET.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_expressionlist.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rBRACKET.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "baseaccess"

	public static class objectcreationexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "objectcreationexpression"
	// ../rsc/CSharp.g3:759:1: objectcreationexpression : nEW type lPAREN ( argumentlist )? rPAREN -> ^( ObjectCreationExpression nEW type lPAREN ( argumentlist )? rPAREN ) ;
	public final CSharpParser.objectcreationexpression_return objectcreationexpression()
			throws RecognitionException {
		CSharpParser.objectcreationexpression_return retval =
			new CSharpParser.objectcreationexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW255 = null;

		CSharpParser.type_return type256 = null;

		CSharpParser.lPAREN_return lPAREN257 = null;

		CSharpParser.argumentlist_return argumentlist258 = null;

		CSharpParser.rPAREN_return rPAREN259 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_nEW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nEW");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_argumentlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule argumentlist");
		try {
			// ../rsc/CSharp.g3:760:5: ( nEW type lPAREN ( argumentlist )? rPAREN -> ^( ObjectCreationExpression nEW type lPAREN ( argumentlist )? rPAREN ) )
			// ../rsc/CSharp.g3:760:9: nEW type lPAREN ( argumentlist )? rPAREN
			{
				pushFollow(FOLLOW_nEW_in_objectcreationexpression3860);
				nEW255 = nEW();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_nEW.add(nEW255.getTree());
				pushFollow(FOLLOW_type_in_objectcreationexpression3862);
				type256 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type256.getTree());
				pushFollow(FOLLOW_lPAREN_in_objectcreationexpression3864);
				lPAREN257 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN257.getTree());
				// ../rsc/CSharp.g3:760:25: ( argumentlist )?
				int alt49 = 2;
				int LA49_0 = this.input.LA(1);

				if ((LA49_0 == LPAREN || (LA49_0 >= PLUS && LA49_0 <= MINUS)
						|| (LA49_0 >= EXCLAM && LA49_0 <= TILDE)
						|| (LA49_0 >= INCREMENT && LA49_0 <= DECREMENT)
						|| (LA49_0 >= BASE && LA49_0 <= BOOL) || LA49_0 == BYTE
						|| (LA49_0 >= CHAR && LA49_0 <= CHECKED)
						|| (LA49_0 >= DECIMAL && LA49_0 <= DELEGATE)
						|| LA49_0 == DOUBLE || LA49_0 == FALSE
						|| LA49_0 == FLOAT || LA49_0 == INT || LA49_0 == LONG
						|| (LA49_0 >= NEW && LA49_0 <= OBJECT) || LA49_0 == OUT
						|| LA49_0 == REF || LA49_0 == SBYTE || LA49_0 == SHORT
						|| LA49_0 == STRING || LA49_0 == THIS || LA49_0 == TRUE
						|| (LA49_0 >= TYPEOF && LA49_0 <= UNCHECKED)
						|| LA49_0 == USHORT || (LA49_0 >= ADD && LA49_0 <= Stringliteral))) {
					alt49 = 1;
				}
				switch (alt49) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: argumentlist
						{
							pushFollow(FOLLOW_argumentlist_in_objectcreationexpression3866);
							argumentlist258 = argumentlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_argumentlist.add(argumentlist258
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_objectcreationexpression3869);
				rPAREN259 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN259.getTree());

				// AST REWRITE
				// elements: argumentlist, lPAREN, type, nEW, rPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 761:5: -> ^( ObjectCreationExpression nEW type lPAREN ( argumentlist )? rPAREN )
					{
						// ../rsc/CSharp.g3:761:8: ^( ObjectCreationExpression nEW type lPAREN ( argumentlist )? rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ObjectCreationExpression,
										"ObjectCreationExpression"), root_1);

							this.adaptor.addChild(root_1, stream_nEW.nextTree());
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							// ../rsc/CSharp.g3:761:51: ( argumentlist )?
							if (stream_argumentlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_argumentlist.nextTree());

							}
							stream_argumentlist.reset();
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "objectcreationexpression"

	public static class arraycreationexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "arraycreationexpression"
	// ../rsc/CSharp.g3:766:1: arraycreationexpression : ( arraycreationexpression_withinitializer | arraycreationexpression_withoutinitializer );
	public final CSharpParser.arraycreationexpression_return arraycreationexpression()
			throws RecognitionException {
		CSharpParser.arraycreationexpression_return retval =
			new CSharpParser.arraycreationexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.arraycreationexpression_withinitializer_return arraycreationexpression_withinitializer260 =
			null;

		CSharpParser.arraycreationexpression_withoutinitializer_return arraycreationexpression_withoutinitializer261 =
			null;

		try {
			// ../rsc/CSharp.g3:767:2: ( arraycreationexpression_withinitializer | arraycreationexpression_withoutinitializer )
			int alt50 = 2;
			int LA50_0 = this.input.LA(1);

			if ((LA50_0 == NEW)) {
				this.input.LA(2);

				if ((synpred190_CSharp())) {
					alt50 = 1;
				}
				else if ((true)) {
					alt50 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 50, 0, this.input);

				throw nvae;
			}
			switch (alt50) {
				case 1 :
				// ../rsc/CSharp.g3:767:4: arraycreationexpression_withinitializer
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_arraycreationexpression_withinitializer_in_arraycreationexpression3906);
						arraycreationexpression_withinitializer260 =
							arraycreationexpression_withinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								arraycreationexpression_withinitializer260
									.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:768:4: arraycreationexpression_withoutinitializer
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_arraycreationexpression_withoutinitializer_in_arraycreationexpression3911);
						arraycreationexpression_withoutinitializer261 =
							arraycreationexpression_withoutinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								arraycreationexpression_withoutinitializer261
									.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "arraycreationexpression"

	public static class arraycreationexpression_withinitializer_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "arraycreationexpression_withinitializer"
	// ../rsc/CSharp.g3:772:1: arraycreationexpression_withinitializer : ( nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer -> ^( ArrayCreationExpression nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer ) | nEW nonarraytype rankspecifiers arrayinitializer -> ^( ArrayCreationExpression nEW nonarraytype rankspecifiers arrayinitializer ) );
	public final CSharpParser.arraycreationexpression_withinitializer_return arraycreationexpression_withinitializer()
			throws RecognitionException {
		CSharpParser.arraycreationexpression_withinitializer_return retval =
			new CSharpParser.arraycreationexpression_withinitializer_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW262 = null;

		CSharpParser.nonarraytype_return nonarraytype263 = null;

		CSharpParser.lBRACKET_return lBRACKET264 = null;

		CSharpParser.expressionlist_return expressionlist265 = null;

		CSharpParser.rBRACKET_return rBRACKET266 = null;

		CSharpParser.rankspecifiers_return rankspecifiers267 = null;

		CSharpParser.arrayinitializer_return arrayinitializer268 = null;

		CSharpParser.nEW_return nEW269 = null;

		CSharpParser.nonarraytype_return nonarraytype270 = null;

		CSharpParser.rankspecifiers_return rankspecifiers271 = null;

		CSharpParser.arrayinitializer_return arrayinitializer272 = null;

		RewriteRuleSubtreeStream stream_lBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACKET");
		RewriteRuleSubtreeStream stream_rankspecifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rankspecifiers");
		RewriteRuleSubtreeStream stream_expressionlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expressionlist");
		RewriteRuleSubtreeStream stream_nonarraytype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nonarraytype");
		RewriteRuleSubtreeStream stream_arrayinitializer =
			new RewriteRuleSubtreeStream(this.adaptor, "rule arrayinitializer");
		RewriteRuleSubtreeStream stream_nEW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nEW");
		RewriteRuleSubtreeStream stream_rBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACKET");
		try {
			// ../rsc/CSharp.g3:775:5: ( nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer -> ^( ArrayCreationExpression nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer ) | nEW nonarraytype rankspecifiers arrayinitializer -> ^( ArrayCreationExpression nEW nonarraytype rankspecifiers arrayinitializer ) )
			int alt52 = 2;
			int LA52_0 = this.input.LA(1);

			if ((LA52_0 == NEW)) {
				this.input.LA(2);

				if ((synpred192_CSharp())) {
					alt52 = 1;
				}
				else if ((true)) {
					alt52 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 52, 0, this.input);

				throw nvae;
			}
			switch (alt52) {
				case 1 :
				// ../rsc/CSharp.g3:775:9: nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer
					{
						pushFollow(FOLLOW_nEW_in_arraycreationexpression_withinitializer3932);
						nEW262 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_nEW.add(nEW262.getTree());
						pushFollow(FOLLOW_nonarraytype_in_arraycreationexpression_withinitializer3934);
						nonarraytype263 = nonarraytype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_nonarraytype.add(nonarraytype263.getTree());
						pushFollow(FOLLOW_lBRACKET_in_arraycreationexpression_withinitializer3936);
						lBRACKET264 = lBRACKET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACKET.add(lBRACKET264.getTree());
						pushFollow(FOLLOW_expressionlist_in_arraycreationexpression_withinitializer3938);
						expressionlist265 = expressionlist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_expressionlist.add(expressionlist265
								.getTree());
						pushFollow(FOLLOW_rBRACKET_in_arraycreationexpression_withinitializer3940);
						rBRACKET266 = rBRACKET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACKET.add(rBRACKET266.getTree());
						// ../rsc/CSharp.g3:775:59: ( rankspecifiers )?
						int alt51 = 2;
						int LA51_0 = this.input.LA(1);

						if ((LA51_0 == LBRACKET)) {
							alt51 = 1;
						}
						switch (alt51) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: rankspecifiers
								{
									pushFollow(FOLLOW_rankspecifiers_in_arraycreationexpression_withinitializer3942);
									rankspecifiers267 = rankspecifiers();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_rankspecifiers
											.add(rankspecifiers267.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_arrayinitializer_in_arraycreationexpression_withinitializer3945);
						arrayinitializer268 = arrayinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_arrayinitializer.add(arrayinitializer268
								.getTree());

						// AST REWRITE
						// elements: rankspecifiers, expressionlist, lBRACKET, nonarraytype, nEW, arrayinitializer, rBRACKET
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 776:5: -> ^( ArrayCreationExpression nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer )
							{
								// ../rsc/CSharp.g3:776:8: ^( ArrayCreationExpression nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ArrayCreationExpression,
												"ArrayCreationExpression"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_nEW.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_nonarraytype.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lBRACKET.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_expressionlist.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rBRACKET.nextTree());
									// ../rsc/CSharp.g3:776:84: ( rankspecifiers )?
									if (stream_rankspecifiers.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_rankspecifiers.nextTree());

									}
									stream_rankspecifiers.reset();
									this.adaptor.addChild(
										root_1,
										stream_arrayinitializer.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:781:7: nEW nonarraytype rankspecifiers arrayinitializer
					{
						pushFollow(FOLLOW_nEW_in_arraycreationexpression_withinitializer3998);
						nEW269 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_nEW.add(nEW269.getTree());
						pushFollow(FOLLOW_nonarraytype_in_arraycreationexpression_withinitializer4000);
						nonarraytype270 = nonarraytype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_nonarraytype.add(nonarraytype270.getTree());
						pushFollow(FOLLOW_rankspecifiers_in_arraycreationexpression_withinitializer4002);
						rankspecifiers271 = rankspecifiers();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rankspecifiers.add(rankspecifiers271
								.getTree());
						pushFollow(FOLLOW_arrayinitializer_in_arraycreationexpression_withinitializer4004);
						arrayinitializer272 = arrayinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_arrayinitializer.add(arrayinitializer272
								.getTree());

						// AST REWRITE
						// elements: nonarraytype, rankspecifiers, arrayinitializer, nEW
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 782:5: -> ^( ArrayCreationExpression nEW nonarraytype rankspecifiers arrayinitializer )
							{
								// ../rsc/CSharp.g3:782:8: ^( ArrayCreationExpression nEW nonarraytype rankspecifiers arrayinitializer )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ArrayCreationExpression,
												"ArrayCreationExpression"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_nEW.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_nonarraytype.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rankspecifiers.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_arrayinitializer.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "arraycreationexpression_withinitializer"

	public static class arraycreationexpression_withoutinitializer_return
			extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "arraycreationexpression_withoutinitializer"
	// ../rsc/CSharp.g3:785:1: arraycreationexpression_withoutinitializer : nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? -> ^( ArrayCreationExpression nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? ) ;
	public final CSharpParser.arraycreationexpression_withoutinitializer_return arraycreationexpression_withoutinitializer()
			throws RecognitionException {
		CSharpParser.arraycreationexpression_withoutinitializer_return retval =
			new CSharpParser.arraycreationexpression_withoutinitializer_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW273 = null;

		CSharpParser.nonarraytype_return nonarraytype274 = null;

		CSharpParser.lBRACKET_return lBRACKET275 = null;

		CSharpParser.expressionlist_return expressionlist276 = null;

		CSharpParser.rBRACKET_return rBRACKET277 = null;

		CSharpParser.rankspecifiers_return rankspecifiers278 = null;

		RewriteRuleSubtreeStream stream_lBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACKET");
		RewriteRuleSubtreeStream stream_rankspecifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rankspecifiers");
		RewriteRuleSubtreeStream stream_expressionlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expressionlist");
		RewriteRuleSubtreeStream stream_nonarraytype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nonarraytype");
		RewriteRuleSubtreeStream stream_nEW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nEW");
		RewriteRuleSubtreeStream stream_rBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACKET");
		try {
			// ../rsc/CSharp.g3:786:5: ( nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? -> ^( ArrayCreationExpression nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? ) )
			// ../rsc/CSharp.g3:786:7: nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )?
			{
				pushFollow(FOLLOW_nEW_in_arraycreationexpression_withoutinitializer4039);
				nEW273 = nEW();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_nEW.add(nEW273.getTree());
				pushFollow(FOLLOW_nonarraytype_in_arraycreationexpression_withoutinitializer4041);
				nonarraytype274 = nonarraytype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_nonarraytype.add(nonarraytype274.getTree());
				pushFollow(FOLLOW_lBRACKET_in_arraycreationexpression_withoutinitializer4043);
				lBRACKET275 = lBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACKET.add(lBRACKET275.getTree());
				pushFollow(FOLLOW_expressionlist_in_arraycreationexpression_withoutinitializer4045);
				expressionlist276 = expressionlist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expressionlist.add(expressionlist276.getTree());
				pushFollow(FOLLOW_rBRACKET_in_arraycreationexpression_withoutinitializer4047);
				rBRACKET277 = rBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACKET.add(rBRACKET277.getTree());
				// ../rsc/CSharp.g3:786:57: ( rankspecifiers )?
				int alt53 = 2;
				alt53 = this.dfa53.predict(this.input);
				switch (alt53) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: rankspecifiers
						{
							pushFollow(FOLLOW_rankspecifiers_in_arraycreationexpression_withoutinitializer4049);
							rankspecifiers278 = rankspecifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_rankspecifiers.add(rankspecifiers278
									.getTree());

						}
						break;

				}

				// AST REWRITE
				// elements: rankspecifiers, expressionlist, nonarraytype, rBRACKET, lBRACKET, nEW
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 787:5: -> ^( ArrayCreationExpression nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? )
					{
						// ../rsc/CSharp.g3:787:8: ^( ArrayCreationExpression nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ArrayCreationExpression,
										"ArrayCreationExpression"), root_1);

							this.adaptor.addChild(root_1, stream_nEW.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_nonarraytype.nextTree());
							this.adaptor
								.addChild(root_1, stream_lBRACKET.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_expressionlist.nextTree());
							this.adaptor
								.addChild(root_1, stream_rBRACKET.nextTree());
							// ../rsc/CSharp.g3:787:84: ( rankspecifiers )?
							if (stream_rankspecifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_rankspecifiers.nextTree());

							}
							stream_rankspecifiers.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "arraycreationexpression_withoutinitializer"

	public static class typeofexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeofexpression"
	// ../rsc/CSharp.g3:790:1: typeofexpression : ( tYPEOF lPAREN type rPAREN -> ^( TypeOfExpression tYPEOF lPAREN type rPAREN ) | tYPEOF lPAREN unboundtypename rPAREN -> ^( TypeOfExpression tYPEOF lPAREN unboundtypename rPAREN ) | tYPEOF lPAREN vOID rPAREN -> ^( TypeOfExpression tYPEOF lPAREN vOID rPAREN ) );
	public final CSharpParser.typeofexpression_return typeofexpression()
			throws RecognitionException {
		CSharpParser.typeofexpression_return retval =
			new CSharpParser.typeofexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.tYPEOF_return tYPEOF279 = null;

		CSharpParser.lPAREN_return lPAREN280 = null;

		CSharpParser.type_return type281 = null;

		CSharpParser.rPAREN_return rPAREN282 = null;

		CSharpParser.tYPEOF_return tYPEOF283 = null;

		CSharpParser.lPAREN_return lPAREN284 = null;

		CSharpParser.unboundtypename_return unboundtypename285 = null;

		CSharpParser.rPAREN_return rPAREN286 = null;

		CSharpParser.tYPEOF_return tYPEOF287 = null;

		CSharpParser.lPAREN_return lPAREN288 = null;

		CSharpParser.vOID_return vOID289 = null;

		CSharpParser.rPAREN_return rPAREN290 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_vOID =
			new RewriteRuleSubtreeStream(this.adaptor, "rule vOID");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_unboundtypename =
			new RewriteRuleSubtreeStream(this.adaptor, "rule unboundtypename");
		RewriteRuleSubtreeStream stream_tYPEOF =
			new RewriteRuleSubtreeStream(this.adaptor, "rule tYPEOF");
		try {
			// ../rsc/CSharp.g3:799:5: ( tYPEOF lPAREN type rPAREN -> ^( TypeOfExpression tYPEOF lPAREN type rPAREN ) | tYPEOF lPAREN unboundtypename rPAREN -> ^( TypeOfExpression tYPEOF lPAREN unboundtypename rPAREN ) | tYPEOF lPAREN vOID rPAREN -> ^( TypeOfExpression tYPEOF lPAREN vOID rPAREN ) )
			int alt54 = 3;
			alt54 = this.dfa54.predict(this.input);
			switch (alt54) {
				case 1 :
				// ../rsc/CSharp.g3:799:9: tYPEOF lPAREN type rPAREN
					{
						pushFollow(FOLLOW_tYPEOF_in_typeofexpression4098);
						tYPEOF279 = tYPEOF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_tYPEOF.add(tYPEOF279.getTree());
						pushFollow(FOLLOW_lPAREN_in_typeofexpression4100);
						lPAREN280 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN280.getTree());
						pushFollow(FOLLOW_type_in_typeofexpression4102);
						type281 = type();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_type.add(type281.getTree());
						pushFollow(FOLLOW_rPAREN_in_typeofexpression4104);
						rPAREN282 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN282.getTree());

						// AST REWRITE
						// elements: type, tYPEOF, lPAREN, rPAREN
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 800:5: -> ^( TypeOfExpression tYPEOF lPAREN type rPAREN )
							{
								// ../rsc/CSharp.g3:800:8: ^( TypeOfExpression tYPEOF lPAREN type rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeOfExpression,
												"TypeOfExpression"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_tYPEOF.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_type.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:801:9: tYPEOF lPAREN unboundtypename rPAREN
					{
						pushFollow(FOLLOW_tYPEOF_in_typeofexpression4132);
						tYPEOF283 = tYPEOF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_tYPEOF.add(tYPEOF283.getTree());
						pushFollow(FOLLOW_lPAREN_in_typeofexpression4134);
						lPAREN284 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN284.getTree());
						pushFollow(FOLLOW_unboundtypename_in_typeofexpression4136);
						unboundtypename285 = unboundtypename();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_unboundtypename.add(unboundtypename285
								.getTree());
						pushFollow(FOLLOW_rPAREN_in_typeofexpression4138);
						rPAREN286 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN286.getTree());

						// AST REWRITE
						// elements: unboundtypename, rPAREN, lPAREN, tYPEOF
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 802:5: -> ^( TypeOfExpression tYPEOF lPAREN unboundtypename rPAREN )
							{
								// ../rsc/CSharp.g3:802:8: ^( TypeOfExpression tYPEOF lPAREN unboundtypename rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeOfExpression,
												"TypeOfExpression"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_tYPEOF.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_unboundtypename.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:803:9: tYPEOF lPAREN vOID rPAREN
					{
						pushFollow(FOLLOW_tYPEOF_in_typeofexpression4166);
						tYPEOF287 = tYPEOF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_tYPEOF.add(tYPEOF287.getTree());
						pushFollow(FOLLOW_lPAREN_in_typeofexpression4168);
						lPAREN288 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN288.getTree());
						pushFollow(FOLLOW_vOID_in_typeofexpression4170);
						vOID289 = vOID();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_vOID.add(vOID289.getTree());
						pushFollow(FOLLOW_rPAREN_in_typeofexpression4172);
						rPAREN290 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN290.getTree());

						// AST REWRITE
						// elements: rPAREN, vOID, lPAREN, tYPEOF
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 804:5: -> ^( TypeOfExpression tYPEOF lPAREN vOID rPAREN )
							{
								// ../rsc/CSharp.g3:804:8: ^( TypeOfExpression tYPEOF lPAREN vOID rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeOfExpression,
												"TypeOfExpression"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_tYPEOF.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_vOID.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeofexpression"

	public static class unboundtypename_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "unboundtypename"
	// ../rsc/CSharp.g3:807:1: unboundtypename : ( identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* -> ^( UnboundTypeName identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* ) | identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* -> ^( UnboundTypeName identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* ) );
	public final CSharpParser.unboundtypename_return unboundtypename()
			throws RecognitionException {
		CSharpParser.unboundtypename_return retval =
			new CSharpParser.unboundtypename_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier291 = null;

		CSharpParser.genericdimensionspecifier_return genericdimensionspecifier292 =
			null;

		CSharpParser.dOT_return dOT293 = null;

		CSharpParser.identifier_return identifier294 = null;

		CSharpParser.genericdimensionspecifier_return genericdimensionspecifier295 =
			null;

		CSharpParser.identifier_return identifier296 = null;

		CSharpParser.dOUBLECOLON_return dOUBLECOLON297 = null;

		CSharpParser.identifier_return identifier298 = null;

		CSharpParser.genericdimensionspecifier_return genericdimensionspecifier299 =
			null;

		CSharpParser.dOT_return dOT300 = null;

		CSharpParser.identifier_return identifier301 = null;

		CSharpParser.genericdimensionspecifier_return genericdimensionspecifier302 =
			null;

		RewriteRuleSubtreeStream stream_genericdimensionspecifier =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule genericdimensionspecifier");
		RewriteRuleSubtreeStream stream_dOT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dOT");
		RewriteRuleSubtreeStream stream_dOUBLECOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dOUBLECOLON");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:808:5: ( identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* -> ^( UnboundTypeName identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* ) | identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* -> ^( UnboundTypeName identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* ) )
			int alt61 = 2;
			alt61 = this.dfa61.predict(this.input);
			switch (alt61) {
				case 1 :
				// ../rsc/CSharp.g3:808:9: identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )*
					{
						pushFollow(FOLLOW_identifier_in_unboundtypename4213);
						identifier291 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier291.getTree());
						// ../rsc/CSharp.g3:808:20: ( genericdimensionspecifier )?
						int alt55 = 2;
						int LA55_0 = this.input.LA(1);

						if ((LA55_0 == LT)) {
							alt55 = 1;
						}
						switch (alt55) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: genericdimensionspecifier
								{
									pushFollow(FOLLOW_genericdimensionspecifier_in_unboundtypename4215);
									genericdimensionspecifier292 =
										genericdimensionspecifier();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_genericdimensionspecifier
											.add(genericdimensionspecifier292
												.getTree());

								}
								break;

						}

						// ../rsc/CSharp.g3:808:48: ( dOT identifier ( genericdimensionspecifier )? )*
						loop57: do {
							int alt57 = 2;
							int LA57_0 = this.input.LA(1);

							if ((LA57_0 == DOT)) {
								alt57 = 1;
							}

							switch (alt57) {
								case 1 :
								// ../rsc/CSharp.g3:808:49: dOT identifier ( genericdimensionspecifier )?
									{
										pushFollow(FOLLOW_dOT_in_unboundtypename4220);
										dOT293 = dOT();

										this.state._fsp--;
										if (this.state.failed)
											return retval;
										if (this.state.backtracking == 0)
											stream_dOT.add(dOT293.getTree());
										pushFollow(FOLLOW_identifier_in_unboundtypename4222);
										identifier294 = identifier();

										this.state._fsp--;
										if (this.state.failed)
											return retval;
										if (this.state.backtracking == 0)
											stream_identifier.add(identifier294
												.getTree());
										// ../rsc/CSharp.g3:808:64: ( genericdimensionspecifier )?
										int alt56 = 2;
										int LA56_0 = this.input.LA(1);

										if ((LA56_0 == LT)) {
											alt56 = 1;
										}
										switch (alt56) {
											case 1 :
											// ../rsc/CSharp.g3:0:0: genericdimensionspecifier
												{
													pushFollow(FOLLOW_genericdimensionspecifier_in_unboundtypename4224);
													genericdimensionspecifier295 =
														genericdimensionspecifier();

													this.state._fsp--;
													if (this.state.failed)
														return retval;
													if (this.state.backtracking == 0)
														stream_genericdimensionspecifier
															.add(genericdimensionspecifier295
																.getTree());

												}
												break;

										}

									}
									break;

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

						// AST REWRITE
						// elements: genericdimensionspecifier, identifier, identifier, genericdimensionspecifier, dOT
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 809:5: -> ^( UnboundTypeName identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* )
							{
								// ../rsc/CSharp.g3:809:8: ^( UnboundTypeName identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												UnboundTypeName,
												"UnboundTypeName"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());
									// ../rsc/CSharp.g3:809:37: ( genericdimensionspecifier )?
									if (stream_genericdimensionspecifier
										.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_genericdimensionspecifier
												.nextTree());

									}
									stream_genericdimensionspecifier.reset();
									// ../rsc/CSharp.g3:809:65: ( dOT identifier ( genericdimensionspecifier )? )*
									while (stream_identifier.hasNext()
											|| stream_dOT.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_dOT.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_identifier.nextTree());
										// ../rsc/CSharp.g3:809:81: ( genericdimensionspecifier )?
										if (stream_genericdimensionspecifier
											.hasNext()) {
											this.adaptor.addChild(
												root_1,
												stream_genericdimensionspecifier
													.nextTree());

										}
										stream_genericdimensionspecifier
											.reset();

									}
									stream_identifier.reset();
									stream_dOT.reset();

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:810:8: identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )*
					{
						pushFollow(FOLLOW_identifier_in_unboundtypename4262);
						identifier296 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier296.getTree());
						pushFollow(FOLLOW_dOUBLECOLON_in_unboundtypename4264);
						dOUBLECOLON297 = dOUBLECOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_dOUBLECOLON.add(dOUBLECOLON297.getTree());
						pushFollow(FOLLOW_identifier_in_unboundtypename4266);
						identifier298 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier298.getTree());
						// ../rsc/CSharp.g3:810:42: ( genericdimensionspecifier )?
						int alt58 = 2;
						int LA58_0 = this.input.LA(1);

						if ((LA58_0 == LT)) {
							alt58 = 1;
						}
						switch (alt58) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: genericdimensionspecifier
								{
									pushFollow(FOLLOW_genericdimensionspecifier_in_unboundtypename4268);
									genericdimensionspecifier299 =
										genericdimensionspecifier();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_genericdimensionspecifier
											.add(genericdimensionspecifier299
												.getTree());

								}
								break;

						}

						// ../rsc/CSharp.g3:810:69: ( dOT identifier ( genericdimensionspecifier )? )*
						loop60: do {
							int alt60 = 2;
							int LA60_0 = this.input.LA(1);

							if ((LA60_0 == DOT)) {
								alt60 = 1;
							}

							switch (alt60) {
								case 1 :
								// ../rsc/CSharp.g3:810:70: dOT identifier ( genericdimensionspecifier )?
									{
										pushFollow(FOLLOW_dOT_in_unboundtypename4272);
										dOT300 = dOT();

										this.state._fsp--;
										if (this.state.failed)
											return retval;
										if (this.state.backtracking == 0)
											stream_dOT.add(dOT300.getTree());
										pushFollow(FOLLOW_identifier_in_unboundtypename4274);
										identifier301 = identifier();

										this.state._fsp--;
										if (this.state.failed)
											return retval;
										if (this.state.backtracking == 0)
											stream_identifier.add(identifier301
												.getTree());
										// ../rsc/CSharp.g3:810:85: ( genericdimensionspecifier )?
										int alt59 = 2;
										int LA59_0 = this.input.LA(1);

										if ((LA59_0 == LT)) {
											alt59 = 1;
										}
										switch (alt59) {
											case 1 :
											// ../rsc/CSharp.g3:0:0: genericdimensionspecifier
												{
													pushFollow(FOLLOW_genericdimensionspecifier_in_unboundtypename4276);
													genericdimensionspecifier302 =
														genericdimensionspecifier();

													this.state._fsp--;
													if (this.state.failed)
														return retval;
													if (this.state.backtracking == 0)
														stream_genericdimensionspecifier
															.add(genericdimensionspecifier302
																.getTree());

												}
												break;

										}

									}
									break;

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

						// AST REWRITE
						// elements: identifier, identifier, genericdimensionspecifier, dOT, identifier, dOUBLECOLON, genericdimensionspecifier
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 811:5: -> ^( UnboundTypeName identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* )
							{
								// ../rsc/CSharp.g3:811:8: ^( UnboundTypeName identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												UnboundTypeName,
												"UnboundTypeName"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_dOUBLECOLON.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());
									// ../rsc/CSharp.g3:811:60: ( genericdimensionspecifier )?
									if (stream_genericdimensionspecifier
										.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_genericdimensionspecifier
												.nextTree());

									}
									stream_genericdimensionspecifier.reset();
									// ../rsc/CSharp.g3:811:87: ( dOT identifier ( genericdimensionspecifier )? )*
									while (stream_identifier.hasNext()
											|| stream_dOT.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_dOT.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_identifier.nextTree());
										// ../rsc/CSharp.g3:811:103: ( genericdimensionspecifier )?
										if (stream_genericdimensionspecifier
											.hasNext()) {
											this.adaptor.addChild(
												root_1,
												stream_genericdimensionspecifier
													.nextTree());

										}
										stream_genericdimensionspecifier
											.reset();

									}
									stream_identifier.reset();
									stream_dOT.reset();

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "unboundtypename"

	public static class genericdimensionspecifier_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "genericdimensionspecifier"
	// ../rsc/CSharp.g3:814:1: genericdimensionspecifier : lT ( commas )? gT -> ^( GenericDimensionSpecifier lT ( commas )? gT ) ;
	public final CSharpParser.genericdimensionspecifier_return genericdimensionspecifier()
			throws RecognitionException {
		CSharpParser.genericdimensionspecifier_return retval =
			new CSharpParser.genericdimensionspecifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lT_return lT303 = null;

		CSharpParser.commas_return commas304 = null;

		CSharpParser.gT_return gT305 = null;

		RewriteRuleSubtreeStream stream_lT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lT");
		RewriteRuleSubtreeStream stream_gT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gT");
		RewriteRuleSubtreeStream stream_commas =
			new RewriteRuleSubtreeStream(this.adaptor, "rule commas");
		try {
			// ../rsc/CSharp.g3:815:5: ( lT ( commas )? gT -> ^( GenericDimensionSpecifier lT ( commas )? gT ) )
			// ../rsc/CSharp.g3:815:9: lT ( commas )? gT
			{
				pushFollow(FOLLOW_lT_in_genericdimensionspecifier4327);
				lT303 = lT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lT.add(lT303.getTree());
				// ../rsc/CSharp.g3:815:12: ( commas )?
				int alt62 = 2;
				int LA62_0 = this.input.LA(1);

				if ((LA62_0 == COMMA)) {
					alt62 = 1;
				}
				switch (alt62) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: commas
						{
							pushFollow(FOLLOW_commas_in_genericdimensionspecifier4329);
							commas304 = commas();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_commas.add(commas304.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_gT_in_genericdimensionspecifier4332);
				gT305 = gT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_gT.add(gT305.getTree());

				// AST REWRITE
				// elements: commas, lT, gT
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 816:5: -> ^( GenericDimensionSpecifier lT ( commas )? gT )
					{
						// ../rsc/CSharp.g3:816:8: ^( GenericDimensionSpecifier lT ( commas )? gT )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										GenericDimensionSpecifier,
										"GenericDimensionSpecifier"), root_1);

							this.adaptor.addChild(root_1, stream_lT.nextTree());
							// ../rsc/CSharp.g3:816:39: ( commas )?
							if (stream_commas.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_commas.nextTree());

							}
							stream_commas.reset();
							this.adaptor.addChild(root_1, stream_gT.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "genericdimensionspecifier"

	public static class commas_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "commas"
	// ../rsc/CSharp.g3:819:1: commas : ( cOMMA ) ( cOMMA )* ;
	public final CSharpParser.commas_return commas()
			throws RecognitionException {
		CSharpParser.commas_return retval = new CSharpParser.commas_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cOMMA_return cOMMA306 = null;

		CSharpParser.cOMMA_return cOMMA307 = null;

		try {
			// ../rsc/CSharp.g3:820:5: ( ( cOMMA ) ( cOMMA )* )
			// ../rsc/CSharp.g3:820:9: ( cOMMA ) ( cOMMA )*
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:820:9: ( cOMMA )
				// ../rsc/CSharp.g3:820:10: cOMMA
				{
					pushFollow(FOLLOW_cOMMA_in_commas4370);
					cOMMA306 = cOMMA();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						this.adaptor.addChild(root_0, cOMMA306.getTree());

				}

				// ../rsc/CSharp.g3:820:17: ( cOMMA )*
				loop63: do {
					int alt63 = 2;
					int LA63_0 = this.input.LA(1);

					if ((LA63_0 == COMMA)) {
						alt63 = 1;
					}

					switch (alt63) {
						case 1 :
						// ../rsc/CSharp.g3:820:18: cOMMA
							{
								pushFollow(FOLLOW_cOMMA_in_commas4374);
								cOMMA307 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor
										.addChild(root_0, cOMMA307.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "commas"

	public static class checkedexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "checkedexpression"
	// ../rsc/CSharp.g3:822:1: checkedexpression : cHECKED lPAREN expression rPAREN -> ^( CheckedExpression cHECKED lPAREN expression rPAREN ) ;
	public final CSharpParser.checkedexpression_return checkedexpression()
			throws RecognitionException {
		CSharpParser.checkedexpression_return retval =
			new CSharpParser.checkedexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cHECKED_return cHECKED308 = null;

		CSharpParser.lPAREN_return lPAREN309 = null;

		CSharpParser.expression_return expression310 = null;

		CSharpParser.rPAREN_return rPAREN311 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_cHECKED =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cHECKED");
		try {
			// ../rsc/CSharp.g3:823:5: ( cHECKED lPAREN expression rPAREN -> ^( CheckedExpression cHECKED lPAREN expression rPAREN ) )
			// ../rsc/CSharp.g3:823:9: cHECKED lPAREN expression rPAREN
			{
				pushFollow(FOLLOW_cHECKED_in_checkedexpression4395);
				cHECKED308 = cHECKED();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cHECKED.add(cHECKED308.getTree());
				pushFollow(FOLLOW_lPAREN_in_checkedexpression4397);
				lPAREN309 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN309.getTree());
				pushFollow(FOLLOW_expression_in_checkedexpression4399);
				expression310 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression310.getTree());
				pushFollow(FOLLOW_rPAREN_in_checkedexpression4401);
				rPAREN311 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN311.getTree());

				// AST REWRITE
				// elements: expression, rPAREN, cHECKED, lPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 824:5: -> ^( CheckedExpression cHECKED lPAREN expression rPAREN )
					{
						// ../rsc/CSharp.g3:824:8: ^( CheckedExpression cHECKED lPAREN expression rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										CheckedExpression,
										"CheckedExpression"), root_1);

							this.adaptor.addChild(root_1, stream_cHECKED.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "checkedexpression"

	public static class uncheckedexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "uncheckedexpression"
	// ../rsc/CSharp.g3:827:1: uncheckedexpression : uNCHECKED lPAREN expression rPAREN -> ^( UncheckedExpression uNCHECKED lPAREN expression rPAREN ) ;
	public final CSharpParser.uncheckedexpression_return uncheckedexpression()
			throws RecognitionException {
		CSharpParser.uncheckedexpression_return retval =
			new CSharpParser.uncheckedexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.uNCHECKED_return uNCHECKED312 = null;

		CSharpParser.lPAREN_return lPAREN313 = null;

		CSharpParser.expression_return expression314 = null;

		CSharpParser.rPAREN_return rPAREN315 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_uNCHECKED =
			new RewriteRuleSubtreeStream(this.adaptor, "rule uNCHECKED");
		try {
			// ../rsc/CSharp.g3:828:5: ( uNCHECKED lPAREN expression rPAREN -> ^( UncheckedExpression uNCHECKED lPAREN expression rPAREN ) )
			// ../rsc/CSharp.g3:828:9: uNCHECKED lPAREN expression rPAREN
			{
				pushFollow(FOLLOW_uNCHECKED_in_uncheckedexpression4438);
				uNCHECKED312 = uNCHECKED();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_uNCHECKED.add(uNCHECKED312.getTree());
				pushFollow(FOLLOW_lPAREN_in_uncheckedexpression4440);
				lPAREN313 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN313.getTree());
				pushFollow(FOLLOW_expression_in_uncheckedexpression4442);
				expression314 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression314.getTree());
				pushFollow(FOLLOW_rPAREN_in_uncheckedexpression4444);
				rPAREN315 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN315.getTree());

				// AST REWRITE
				// elements: lPAREN, expression, uNCHECKED, rPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 829:5: -> ^( UncheckedExpression uNCHECKED lPAREN expression rPAREN )
					{
						// ../rsc/CSharp.g3:829:8: ^( UncheckedExpression uNCHECKED lPAREN expression rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										UncheckedExpression,
										"UncheckedExpression"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_uNCHECKED.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "uncheckedexpression"

	public static class defaultvalueexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "defaultvalueexpression"
	// ../rsc/CSharp.g3:832:1: defaultvalueexpression : dEFAULT lPAREN type rPAREN -> ^( DefaultValueExpression dEFAULT lPAREN type rPAREN ) ;
	public final CSharpParser.defaultvalueexpression_return defaultvalueexpression()
			throws RecognitionException {
		CSharpParser.defaultvalueexpression_return retval =
			new CSharpParser.defaultvalueexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.dEFAULT_return dEFAULT316 = null;

		CSharpParser.lPAREN_return lPAREN317 = null;

		CSharpParser.type_return type318 = null;

		CSharpParser.rPAREN_return rPAREN319 = null;

		RewriteRuleSubtreeStream stream_dEFAULT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dEFAULT");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		try {
			// ../rsc/CSharp.g3:833:5: ( dEFAULT lPAREN type rPAREN -> ^( DefaultValueExpression dEFAULT lPAREN type rPAREN ) )
			// ../rsc/CSharp.g3:833:9: dEFAULT lPAREN type rPAREN
			{
				pushFollow(FOLLOW_dEFAULT_in_defaultvalueexpression4481);
				dEFAULT316 = dEFAULT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_dEFAULT.add(dEFAULT316.getTree());
				pushFollow(FOLLOW_lPAREN_in_defaultvalueexpression4483);
				lPAREN317 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN317.getTree());
				pushFollow(FOLLOW_type_in_defaultvalueexpression4485);
				type318 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type318.getTree());
				pushFollow(FOLLOW_rPAREN_in_defaultvalueexpression4487);
				rPAREN319 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN319.getTree());

				// AST REWRITE
				// elements: rPAREN, type, dEFAULT, lPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 834:5: -> ^( DefaultValueExpression dEFAULT lPAREN type rPAREN )
					{
						// ../rsc/CSharp.g3:834:8: ^( DefaultValueExpression dEFAULT lPAREN type rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										DefaultValueExpression,
										"DefaultValueExpression"), root_1);

							this.adaptor.addChild(root_1, stream_dEFAULT.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "defaultvalueexpression"

	public static class anonymousmethodexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "anonymousmethodexpression"
	// ../rsc/CSharp.g3:837:1: anonymousmethodexpression : dELEGATE ( anonymousmethodsignature )? block -> ^( AnonymousMethodExpression dELEGATE ( anonymousmethodsignature )? block ) ;
	public final CSharpParser.anonymousmethodexpression_return anonymousmethodexpression()
			throws RecognitionException {
		CSharpParser.anonymousmethodexpression_return retval =
			new CSharpParser.anonymousmethodexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.dELEGATE_return dELEGATE320 = null;

		CSharpParser.anonymousmethodsignature_return anonymousmethodsignature321 =
			null;

		CSharpParser.block_return block322 = null;

		RewriteRuleSubtreeStream stream_anonymousmethodsignature =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule anonymousmethodsignature");
		RewriteRuleSubtreeStream stream_dELEGATE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dELEGATE");
		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		try {
			// ../rsc/CSharp.g3:838:5: ( dELEGATE ( anonymousmethodsignature )? block -> ^( AnonymousMethodExpression dELEGATE ( anonymousmethodsignature )? block ) )
			// ../rsc/CSharp.g3:838:9: dELEGATE ( anonymousmethodsignature )? block
			{
				pushFollow(FOLLOW_dELEGATE_in_anonymousmethodexpression4524);
				dELEGATE320 = dELEGATE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_dELEGATE.add(dELEGATE320.getTree());
				// ../rsc/CSharp.g3:838:18: ( anonymousmethodsignature )?
				int alt64 = 2;
				int LA64_0 = this.input.LA(1);

				if ((LA64_0 == LPAREN)) {
					alt64 = 1;
				}
				switch (alt64) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: anonymousmethodsignature
						{
							pushFollow(FOLLOW_anonymousmethodsignature_in_anonymousmethodexpression4526);
							anonymousmethodsignature321 =
								anonymousmethodsignature();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_anonymousmethodsignature
									.add(anonymousmethodsignature321.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_block_in_anonymousmethodexpression4529);
				block322 = block();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_block.add(block322.getTree());

				// AST REWRITE
				// elements: dELEGATE, block, anonymousmethodsignature
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 839:5: -> ^( AnonymousMethodExpression dELEGATE ( anonymousmethodsignature )? block )
					{
						// ../rsc/CSharp.g3:839:8: ^( AnonymousMethodExpression dELEGATE ( anonymousmethodsignature )? block )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										AnonymousMethodExpression,
										"AnonymousMethodExpression"), root_1);

							this.adaptor
								.addChild(root_1, stream_dELEGATE.nextTree());
							// ../rsc/CSharp.g3:839:45: ( anonymousmethodsignature )?
							if (stream_anonymousmethodsignature.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_anonymousmethodsignature.nextTree());

							}
							stream_anonymousmethodsignature.reset();
							this.adaptor.addChild(root_1, stream_block.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "anonymousmethodexpression"

	public static class anonymousmethodsignature_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "anonymousmethodsignature"
	// ../rsc/CSharp.g3:842:1: anonymousmethodsignature : lPAREN ( anonymousmethodparameterlist )? rPAREN ;
	public final CSharpParser.anonymousmethodsignature_return anonymousmethodsignature()
			throws RecognitionException {
		CSharpParser.anonymousmethodsignature_return retval =
			new CSharpParser.anonymousmethodsignature_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lPAREN_return lPAREN323 = null;

		CSharpParser.anonymousmethodparameterlist_return anonymousmethodparameterlist324 =
			null;

		CSharpParser.rPAREN_return rPAREN325 = null;

		try {
			// ../rsc/CSharp.g3:843:5: ( lPAREN ( anonymousmethodparameterlist )? rPAREN )
			// ../rsc/CSharp.g3:843:9: lPAREN ( anonymousmethodparameterlist )? rPAREN
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_lPAREN_in_anonymousmethodsignature4565);
				lPAREN323 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, lPAREN323.getTree());
				// ../rsc/CSharp.g3:843:16: ( anonymousmethodparameterlist )?
				int alt65 = 2;
				int LA65_0 = this.input.LA(1);

				if ((LA65_0 == BOOL || LA65_0 == BYTE || LA65_0 == CHAR
						|| LA65_0 == DECIMAL || LA65_0 == DOUBLE
						|| LA65_0 == FLOAT || LA65_0 == INT || LA65_0 == LONG
						|| LA65_0 == OBJECT || LA65_0 == OUT || LA65_0 == REF
						|| LA65_0 == SBYTE || LA65_0 == SHORT
						|| LA65_0 == STRING
						|| (LA65_0 >= UINT && LA65_0 <= ULONG)
						|| LA65_0 == USHORT || (LA65_0 >= ADD && LA65_0 <= Ident))) {
					alt65 = 1;
				}
				switch (alt65) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: anonymousmethodparameterlist
						{
							pushFollow(FOLLOW_anonymousmethodparameterlist_in_anonymousmethodsignature4567);
							anonymousmethodparameterlist324 =
								anonymousmethodparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								this.adaptor.addChild(
									root_0,
									anonymousmethodparameterlist324.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_anonymousmethodsignature4570);
				rPAREN325 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, rPAREN325.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "anonymousmethodsignature"

	public static class anonymousmethodparameterlist_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "anonymousmethodparameterlist"
	// ../rsc/CSharp.g3:846:1: anonymousmethodparameterlist : ( anonymousmethodparameter ) ( cOMMA anonymousmethodparameter )* ;
	public final CSharpParser.anonymousmethodparameterlist_return anonymousmethodparameterlist()
			throws RecognitionException {
		CSharpParser.anonymousmethodparameterlist_return retval =
			new CSharpParser.anonymousmethodparameterlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.anonymousmethodparameter_return anonymousmethodparameter326 =
			null;

		CSharpParser.cOMMA_return cOMMA327 = null;

		CSharpParser.anonymousmethodparameter_return anonymousmethodparameter328 =
			null;

		try {
			// ../rsc/CSharp.g3:847:5: ( ( anonymousmethodparameter ) ( cOMMA anonymousmethodparameter )* )
			// ../rsc/CSharp.g3:847:9: ( anonymousmethodparameter ) ( cOMMA anonymousmethodparameter )*
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:847:9: ( anonymousmethodparameter )
				// ../rsc/CSharp.g3:847:10: anonymousmethodparameter
				{
					pushFollow(FOLLOW_anonymousmethodparameter_in_anonymousmethodparameterlist4591);
					anonymousmethodparameter326 = anonymousmethodparameter();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						this.adaptor.addChild(
							root_0,
							anonymousmethodparameter326.getTree());

				}

				// ../rsc/CSharp.g3:847:36: ( cOMMA anonymousmethodparameter )*
				loop66: do {
					int alt66 = 2;
					int LA66_0 = this.input.LA(1);

					if ((LA66_0 == COMMA)) {
						alt66 = 1;
					}

					switch (alt66) {
						case 1 :
						// ../rsc/CSharp.g3:847:37: cOMMA anonymousmethodparameter
							{
								pushFollow(FOLLOW_cOMMA_in_anonymousmethodparameterlist4595);
								cOMMA327 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor
										.addChild(root_0, cOMMA327.getTree());
								pushFollow(FOLLOW_anonymousmethodparameter_in_anonymousmethodparameterlist4597);
								anonymousmethodparameter328 =
									anonymousmethodparameter();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										anonymousmethodparameter328.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "anonymousmethodparameterlist"

	public static class anonymousmethodparameter_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "anonymousmethodparameter"
	// ../rsc/CSharp.g3:850:1: anonymousmethodparameter : ( parametermodifier )? type identifier -> ^( Parameter ( parametermodifier )? type identifier ) ;
	public final CSharpParser.anonymousmethodparameter_return anonymousmethodparameter()
			throws RecognitionException {
		CSharpParser.anonymousmethodparameter_return retval =
			new CSharpParser.anonymousmethodparameter_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.parametermodifier_return parametermodifier329 = null;

		CSharpParser.type_return type330 = null;

		CSharpParser.identifier_return identifier331 = null;

		RewriteRuleSubtreeStream stream_parametermodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule parametermodifier");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:851:5: ( ( parametermodifier )? type identifier -> ^( Parameter ( parametermodifier )? type identifier ) )
			// ../rsc/CSharp.g3:851:9: ( parametermodifier )? type identifier
			{
				// ../rsc/CSharp.g3:851:9: ( parametermodifier )?
				int alt67 = 2;
				int LA67_0 = this.input.LA(1);

				if ((LA67_0 == OUT || LA67_0 == REF)) {
					alt67 = 1;
				}
				switch (alt67) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: parametermodifier
						{
							pushFollow(FOLLOW_parametermodifier_in_anonymousmethodparameter4618);
							parametermodifier329 = parametermodifier();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_parametermodifier
									.add(parametermodifier329.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_type_in_anonymousmethodparameter4621);
				type330 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type330.getTree());
				pushFollow(FOLLOW_identifier_in_anonymousmethodparameter4623);
				identifier331 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier331.getTree());

				// AST REWRITE
				// elements: identifier, parametermodifier, type
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 852:2: -> ^( Parameter ( parametermodifier )? type identifier )
					{
						// ../rsc/CSharp.g3:852:5: ^( Parameter ( parametermodifier )? type identifier )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Parameter, "Parameter"), root_1);

							// ../rsc/CSharp.g3:852:17: ( parametermodifier )?
							if (stream_parametermodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_parametermodifier.nextTree());

							}
							stream_parametermodifier.reset();
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "anonymousmethodparameter"

	public static class unaryexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "unaryexpression"
	// ../rsc/CSharp.g3:855:1: unaryexpression options {memoize=true; } : ( castexpression | primaryexpression | pLUS unaryexpression | mINUS unaryexpression | eXCLAM unaryexpression | tILDE unaryexpression | preincrementexpression | predecrementexpression );
	public final CSharpParser.unaryexpression_return unaryexpression()
			throws RecognitionException {
		CSharpParser.unaryexpression_return retval =
			new CSharpParser.unaryexpression_return();
		retval.start = this.input.LT(1);
		int unaryexpression_StartIndex = this.input.index();
		Object root_0 = null;

		CSharpParser.castexpression_return castexpression332 = null;

		CSharpParser.primaryexpression_return primaryexpression333 = null;

		CSharpParser.pLUS_return pLUS334 = null;

		CSharpParser.unaryexpression_return unaryexpression335 = null;

		CSharpParser.mINUS_return mINUS336 = null;

		CSharpParser.unaryexpression_return unaryexpression337 = null;

		CSharpParser.eXCLAM_return eXCLAM338 = null;

		CSharpParser.unaryexpression_return unaryexpression339 = null;

		CSharpParser.tILDE_return tILDE340 = null;

		CSharpParser.unaryexpression_return unaryexpression341 = null;

		CSharpParser.preincrementexpression_return preincrementexpression342 =
			null;

		CSharpParser.predecrementexpression_return predecrementexpression343 =
			null;

		try {
			if (this.state.backtracking > 0 && alreadyParsedRule(this.input, 61)) {
				return retval;
			}
			// ../rsc/CSharp.g3:856:5: ( castexpression | primaryexpression | pLUS unaryexpression | mINUS unaryexpression | eXCLAM unaryexpression | tILDE unaryexpression | preincrementexpression | predecrementexpression )
			int alt68 = 8;
			alt68 = this.dfa68.predict(this.input);
			switch (alt68) {
				case 1 :
				// ../rsc/CSharp.g3:856:9: castexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_castexpression_in_unaryexpression4663);
						castexpression332 = castexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								castexpression332.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:857:7: primaryexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_primaryexpression_in_unaryexpression4673);
						primaryexpression333 = primaryexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								primaryexpression333.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:858:9: pLUS unaryexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pLUS_in_unaryexpression4684);
						pLUS334 = pLUS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pLUS334.getTree());
						pushFollow(FOLLOW_unaryexpression_in_unaryexpression4686);
						unaryexpression335 = unaryexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								unaryexpression335.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:859:9: mINUS unaryexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_mINUS_in_unaryexpression4696);
						mINUS336 = mINUS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, mINUS336.getTree());
						pushFollow(FOLLOW_unaryexpression_in_unaryexpression4698);
						unaryexpression337 = unaryexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								unaryexpression337.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:860:9: eXCLAM unaryexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXCLAM_in_unaryexpression4708);
						eXCLAM338 = eXCLAM();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXCLAM338.getTree());
						pushFollow(FOLLOW_unaryexpression_in_unaryexpression4710);
						unaryexpression339 = unaryexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								unaryexpression339.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:861:9: tILDE unaryexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tILDE_in_unaryexpression4720);
						tILDE340 = tILDE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tILDE340.getTree());
						pushFollow(FOLLOW_unaryexpression_in_unaryexpression4722);
						unaryexpression341 = unaryexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								unaryexpression341.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:862:9: preincrementexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_preincrementexpression_in_unaryexpression4732);
						preincrementexpression342 = preincrementexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								preincrementexpression342.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:863:9: predecrementexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_predecrementexpression_in_unaryexpression4742);
						predecrementexpression343 = predecrementexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								predecrementexpression343.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
			if (this.state.backtracking > 0) {
				memoize(this.input, 61, unaryexpression_StartIndex);
			}
		}
		return retval;
	}
	// $ANTLR end "unaryexpression"

	public static class preincrementexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "preincrementexpression"
	// ../rsc/CSharp.g3:866:1: preincrementexpression : iNCREMENT unaryexpression ;
	public final CSharpParser.preincrementexpression_return preincrementexpression()
			throws RecognitionException {
		CSharpParser.preincrementexpression_return retval =
			new CSharpParser.preincrementexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.iNCREMENT_return iNCREMENT344 = null;

		CSharpParser.unaryexpression_return unaryexpression345 = null;

		try {
			// ../rsc/CSharp.g3:867:5: ( iNCREMENT unaryexpression )
			// ../rsc/CSharp.g3:867:9: iNCREMENT unaryexpression
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_iNCREMENT_in_preincrementexpression4761);
				iNCREMENT344 = iNCREMENT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, iNCREMENT344.getTree());
				pushFollow(FOLLOW_unaryexpression_in_preincrementexpression4763);
				unaryexpression345 = unaryexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, unaryexpression345.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "preincrementexpression"

	public static class predecrementexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "predecrementexpression"
	// ../rsc/CSharp.g3:870:1: predecrementexpression : dECREMENT unaryexpression ;
	public final CSharpParser.predecrementexpression_return predecrementexpression()
			throws RecognitionException {
		CSharpParser.predecrementexpression_return retval =
			new CSharpParser.predecrementexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.dECREMENT_return dECREMENT346 = null;

		CSharpParser.unaryexpression_return unaryexpression347 = null;

		try {
			// ../rsc/CSharp.g3:871:5: ( dECREMENT unaryexpression )
			// ../rsc/CSharp.g3:871:9: dECREMENT unaryexpression
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_dECREMENT_in_predecrementexpression4782);
				dECREMENT346 = dECREMENT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, dECREMENT346.getTree());
				pushFollow(FOLLOW_unaryexpression_in_predecrementexpression4784);
				unaryexpression347 = unaryexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, unaryexpression347.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "predecrementexpression"

	public static class castexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "castexpression"
	// ../rsc/CSharp.g3:874:1: castexpression : lPAREN type rPAREN unaryexpression ;
	public final CSharpParser.castexpression_return castexpression()
			throws RecognitionException {
		CSharpParser.castexpression_return retval =
			new CSharpParser.castexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lPAREN_return lPAREN348 = null;

		CSharpParser.type_return type349 = null;

		CSharpParser.rPAREN_return rPAREN350 = null;

		CSharpParser.unaryexpression_return unaryexpression351 = null;

		try {
			// ../rsc/CSharp.g3:875:5: ( lPAREN type rPAREN unaryexpression )
			// ../rsc/CSharp.g3:875:9: lPAREN type rPAREN unaryexpression
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_lPAREN_in_castexpression4803);
				lPAREN348 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, lPAREN348.getTree());
				pushFollow(FOLLOW_type_in_castexpression4805);
				type349 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, type349.getTree());
				pushFollow(FOLLOW_rPAREN_in_castexpression4807);
				rPAREN350 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, rPAREN350.getTree());
				pushFollow(FOLLOW_unaryexpression_in_castexpression4809);
				unaryexpression351 = unaryexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, unaryexpression351.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "castexpression"

	public static class mulTiplicativeexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "mulTiplicativeexpression"
	// ../rsc/CSharp.g3:879:1: mulTiplicativeexpression : ( unaryexpression -> unaryexpression ) ( mUL unaryexpression -> ^( MulTExpression $mulTiplicativeexpression mUL unaryexpression ) | dIV unaryexpression -> ^( DivExpression $mulTiplicativeexpression dIV unaryexpression ) | mOD unaryexpression -> ^( ModExpression $mulTiplicativeexpression mOD unaryexpression ) )* ;
	public final CSharpParser.mulTiplicativeexpression_return mulTiplicativeexpression()
			throws RecognitionException {
		CSharpParser.mulTiplicativeexpression_return retval =
			new CSharpParser.mulTiplicativeexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.unaryexpression_return unaryexpression352 = null;

		CSharpParser.mUL_return mUL353 = null;

		CSharpParser.unaryexpression_return unaryexpression354 = null;

		CSharpParser.dIV_return dIV355 = null;

		CSharpParser.unaryexpression_return unaryexpression356 = null;

		CSharpParser.mOD_return mOD357 = null;

		CSharpParser.unaryexpression_return unaryexpression358 = null;

		RewriteRuleSubtreeStream stream_dIV =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dIV");
		RewriteRuleSubtreeStream stream_mUL =
			new RewriteRuleSubtreeStream(this.adaptor, "rule mUL");
		RewriteRuleSubtreeStream stream_unaryexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule unaryexpression");
		RewriteRuleSubtreeStream stream_mOD =
			new RewriteRuleSubtreeStream(this.adaptor, "rule mOD");
		try {
			// ../rsc/CSharp.g3:880:5: ( ( unaryexpression -> unaryexpression ) ( mUL unaryexpression -> ^( MulTExpression $mulTiplicativeexpression mUL unaryexpression ) | dIV unaryexpression -> ^( DivExpression $mulTiplicativeexpression dIV unaryexpression ) | mOD unaryexpression -> ^( ModExpression $mulTiplicativeexpression mOD unaryexpression ) )* )
			// ../rsc/CSharp.g3:880:9: ( unaryexpression -> unaryexpression ) ( mUL unaryexpression -> ^( MulTExpression $mulTiplicativeexpression mUL unaryexpression ) | dIV unaryexpression -> ^( DivExpression $mulTiplicativeexpression dIV unaryexpression ) | mOD unaryexpression -> ^( ModExpression $mulTiplicativeexpression mOD unaryexpression ) )*
			{
				// ../rsc/CSharp.g3:880:9: ( unaryexpression -> unaryexpression )
				// ../rsc/CSharp.g3:880:10: unaryexpression
				{
					pushFollow(FOLLOW_unaryexpression_in_mulTiplicativeexpression4831);
					unaryexpression352 = unaryexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_unaryexpression
							.add(unaryexpression352.getTree());

					// AST REWRITE
					// elements: unaryexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 880:26: -> unaryexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_unaryexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:881:6: ( mUL unaryexpression -> ^( MulTExpression $mulTiplicativeexpression mUL unaryexpression ) | dIV unaryexpression -> ^( DivExpression $mulTiplicativeexpression dIV unaryexpression ) | mOD unaryexpression -> ^( ModExpression $mulTiplicativeexpression mOD unaryexpression ) )*
				loop69: do {
					int alt69 = 4;
					switch (this.input.LA(1)) {
						case MUL :
							{
								alt69 = 1;
							}
							break;
						case DIV :
							{
								alt69 = 2;
							}
							break;
						case MOD :
							{
								alt69 = 3;
							}
							break;

					}

					switch (alt69) {
						case 1 :
						// ../rsc/CSharp.g3:882:7: mUL unaryexpression
							{
								pushFollow(FOLLOW_mUL_in_mulTiplicativeexpression4851);
								mUL353 = mUL();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_mUL.add(mUL353.getTree());
								pushFollow(FOLLOW_unaryexpression_in_mulTiplicativeexpression4853);
								unaryexpression354 = unaryexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_unaryexpression
										.add(unaryexpression354.getTree());

								// AST REWRITE
								// elements: unaryexpression, mUL, mulTiplicativeexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 882:27: -> ^( MulTExpression $mulTiplicativeexpression mUL unaryexpression )
									{
										// ../rsc/CSharp.g3:882:30: ^( MulTExpression $mulTiplicativeexpression mUL unaryexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														MulTExpression,
														"MulTExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_mUL.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_unaryexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 2 :
						// ../rsc/CSharp.g3:883:9: dIV unaryexpression
							{
								pushFollow(FOLLOW_dIV_in_mulTiplicativeexpression4876);
								dIV355 = dIV();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_dIV.add(dIV355.getTree());
								pushFollow(FOLLOW_unaryexpression_in_mulTiplicativeexpression4878);
								unaryexpression356 = unaryexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_unaryexpression
										.add(unaryexpression356.getTree());

								// AST REWRITE
								// elements: dIV, mulTiplicativeexpression, unaryexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 883:29: -> ^( DivExpression $mulTiplicativeexpression dIV unaryexpression )
									{
										// ../rsc/CSharp.g3:883:32: ^( DivExpression $mulTiplicativeexpression dIV unaryexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														DivExpression,
														"DivExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_dIV.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_unaryexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 3 :
						// ../rsc/CSharp.g3:884:9: mOD unaryexpression
							{
								pushFollow(FOLLOW_mOD_in_mulTiplicativeexpression4901);
								mOD357 = mOD();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_mOD.add(mOD357.getTree());
								pushFollow(FOLLOW_unaryexpression_in_mulTiplicativeexpression4903);
								unaryexpression358 = unaryexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_unaryexpression
										.add(unaryexpression358.getTree());

								// AST REWRITE
								// elements: mulTiplicativeexpression, unaryexpression, mOD
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 884:29: -> ^( ModExpression $mulTiplicativeexpression mOD unaryexpression )
									{
										// ../rsc/CSharp.g3:884:32: ^( ModExpression $mulTiplicativeexpression mOD unaryexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														ModExpression,
														"ModExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_mOD.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_unaryexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "mulTiplicativeexpression"

	public static class additiveexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "additiveexpression"
	// ../rsc/CSharp.g3:888:1: additiveexpression : ( mulTiplicativeexpression -> mulTiplicativeexpression ) ( pLUS mulTiplicativeexpression -> ^( AddExpression $additiveexpression pLUS mulTiplicativeexpression ) | mINUS mulTiplicativeexpression -> ^( SubExpression $additiveexpression mINUS mulTiplicativeexpression ) )* ;
	public final CSharpParser.additiveexpression_return additiveexpression()
			throws RecognitionException {
		CSharpParser.additiveexpression_return retval =
			new CSharpParser.additiveexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.mulTiplicativeexpression_return mulTiplicativeexpression359 =
			null;

		CSharpParser.pLUS_return pLUS360 = null;

		CSharpParser.mulTiplicativeexpression_return mulTiplicativeexpression361 =
			null;

		CSharpParser.mINUS_return mINUS362 = null;

		CSharpParser.mulTiplicativeexpression_return mulTiplicativeexpression363 =
			null;

		RewriteRuleSubtreeStream stream_mINUS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule mINUS");
		RewriteRuleSubtreeStream stream_mulTiplicativeexpression =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule mulTiplicativeexpression");
		RewriteRuleSubtreeStream stream_pLUS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule pLUS");
		try {
			// ../rsc/CSharp.g3:889:5: ( ( mulTiplicativeexpression -> mulTiplicativeexpression ) ( pLUS mulTiplicativeexpression -> ^( AddExpression $additiveexpression pLUS mulTiplicativeexpression ) | mINUS mulTiplicativeexpression -> ^( SubExpression $additiveexpression mINUS mulTiplicativeexpression ) )* )
			// ../rsc/CSharp.g3:889:9: ( mulTiplicativeexpression -> mulTiplicativeexpression ) ( pLUS mulTiplicativeexpression -> ^( AddExpression $additiveexpression pLUS mulTiplicativeexpression ) | mINUS mulTiplicativeexpression -> ^( SubExpression $additiveexpression mINUS mulTiplicativeexpression ) )*
			{
				// ../rsc/CSharp.g3:889:9: ( mulTiplicativeexpression -> mulTiplicativeexpression )
				// ../rsc/CSharp.g3:889:10: mulTiplicativeexpression
				{
					pushFollow(FOLLOW_mulTiplicativeexpression_in_additiveexpression4945);
					mulTiplicativeexpression359 = mulTiplicativeexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_mulTiplicativeexpression
							.add(mulTiplicativeexpression359.getTree());

					// AST REWRITE
					// elements: mulTiplicativeexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 889:35: -> mulTiplicativeexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_mulTiplicativeexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:890:6: ( pLUS mulTiplicativeexpression -> ^( AddExpression $additiveexpression pLUS mulTiplicativeexpression ) | mINUS mulTiplicativeexpression -> ^( SubExpression $additiveexpression mINUS mulTiplicativeexpression ) )*
				loop70: do {
					int alt70 = 3;
					int LA70_0 = this.input.LA(1);

					if ((LA70_0 == PLUS)) {
						alt70 = 1;
					}
					else if ((LA70_0 == MINUS)) {
						alt70 = 2;
					}

					switch (alt70) {
						case 1 :
						// ../rsc/CSharp.g3:891:7: pLUS mulTiplicativeexpression
							{
								pushFollow(FOLLOW_pLUS_in_additiveexpression4965);
								pLUS360 = pLUS();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_pLUS.add(pLUS360.getTree());
								pushFollow(FOLLOW_mulTiplicativeexpression_in_additiveexpression4967);
								mulTiplicativeexpression361 =
									mulTiplicativeexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_mulTiplicativeexpression
										.add(mulTiplicativeexpression361
											.getTree());

								// AST REWRITE
								// elements: mulTiplicativeexpression, pLUS, additiveexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 891:38: -> ^( AddExpression $additiveexpression pLUS mulTiplicativeexpression )
									{
										// ../rsc/CSharp.g3:891:41: ^( AddExpression $additiveexpression pLUS mulTiplicativeexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														AddExpression,
														"AddExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_pLUS.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_mulTiplicativeexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 2 :
						// ../rsc/CSharp.g3:892:8: mINUS mulTiplicativeexpression
							{
								pushFollow(FOLLOW_mINUS_in_additiveexpression4990);
								mINUS362 = mINUS();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_mINUS.add(mINUS362.getTree());
								pushFollow(FOLLOW_mulTiplicativeexpression_in_additiveexpression4992);
								mulTiplicativeexpression363 =
									mulTiplicativeexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_mulTiplicativeexpression
										.add(mulTiplicativeexpression363
											.getTree());

								// AST REWRITE
								// elements: mulTiplicativeexpression, additiveexpression, mINUS
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 892:40: -> ^( SubExpression $additiveexpression mINUS mulTiplicativeexpression )
									{
										// ../rsc/CSharp.g3:892:43: ^( SubExpression $additiveexpression mINUS mulTiplicativeexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														SubExpression,
														"SubExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_mINUS.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_mulTiplicativeexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "additiveexpression"

	public static class shiftexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "shiftexpression"
	// ../rsc/CSharp.g3:896:1: shiftexpression : ( additiveexpression -> additiveexpression ) ( lEFTSHIFT additiveexpression -> ^( LeftShiftExpression $shiftexpression lEFTSHIFT additiveexpression ) | rIGHTSHIFT additiveexpression -> ^( RightShiftExpression $shiftexpression rIGHTSHIFT additiveexpression ) )* ;
	public final CSharpParser.shiftexpression_return shiftexpression()
			throws RecognitionException {
		CSharpParser.shiftexpression_return retval =
			new CSharpParser.shiftexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.additiveexpression_return additiveexpression364 = null;

		CSharpParser.lEFTSHIFT_return lEFTSHIFT365 = null;

		CSharpParser.additiveexpression_return additiveexpression366 = null;

		CSharpParser.rIGHTSHIFT_return rIGHTSHIFT367 = null;

		CSharpParser.additiveexpression_return additiveexpression368 = null;

		RewriteRuleSubtreeStream stream_rIGHTSHIFT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rIGHTSHIFT");
		RewriteRuleSubtreeStream stream_additiveexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule additiveexpression");
		RewriteRuleSubtreeStream stream_lEFTSHIFT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lEFTSHIFT");
		try {
			// ../rsc/CSharp.g3:897:5: ( ( additiveexpression -> additiveexpression ) ( lEFTSHIFT additiveexpression -> ^( LeftShiftExpression $shiftexpression lEFTSHIFT additiveexpression ) | rIGHTSHIFT additiveexpression -> ^( RightShiftExpression $shiftexpression rIGHTSHIFT additiveexpression ) )* )
			// ../rsc/CSharp.g3:897:9: ( additiveexpression -> additiveexpression ) ( lEFTSHIFT additiveexpression -> ^( LeftShiftExpression $shiftexpression lEFTSHIFT additiveexpression ) | rIGHTSHIFT additiveexpression -> ^( RightShiftExpression $shiftexpression rIGHTSHIFT additiveexpression ) )*
			{
				// ../rsc/CSharp.g3:897:9: ( additiveexpression -> additiveexpression )
				// ../rsc/CSharp.g3:897:10: additiveexpression
				{
					pushFollow(FOLLOW_additiveexpression_in_shiftexpression5035);
					additiveexpression364 = additiveexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_additiveexpression.add(additiveexpression364
							.getTree());

					// AST REWRITE
					// elements: additiveexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 897:29: -> additiveexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_additiveexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:898:6: ( lEFTSHIFT additiveexpression -> ^( LeftShiftExpression $shiftexpression lEFTSHIFT additiveexpression ) | rIGHTSHIFT additiveexpression -> ^( RightShiftExpression $shiftexpression rIGHTSHIFT additiveexpression ) )*
				loop71: do {
					int alt71 = 3;
					int LA71_0 = this.input.LA(1);

					if ((LA71_0 == GT)) {
						int LA71_2 = this.input.LA(2);

						if ((LA71_2 == GT)) {
							alt71 = 2;
						}

					}
					else if ((LA71_0 == LEFTSHIFT)) {
						alt71 = 1;
					}

					switch (alt71) {
						case 1 :
						// ../rsc/CSharp.g3:899:7: lEFTSHIFT additiveexpression
							{
								pushFollow(FOLLOW_lEFTSHIFT_in_shiftexpression5055);
								lEFTSHIFT365 = lEFTSHIFT();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_lEFTSHIFT
										.add(lEFTSHIFT365.getTree());
								pushFollow(FOLLOW_additiveexpression_in_shiftexpression5057);
								additiveexpression366 = additiveexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_additiveexpression
										.add(additiveexpression366.getTree());

								// AST REWRITE
								// elements: lEFTSHIFT, shiftexpression, additiveexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 899:37: -> ^( LeftShiftExpression $shiftexpression lEFTSHIFT additiveexpression )
									{
										// ../rsc/CSharp.g3:899:40: ^( LeftShiftExpression $shiftexpression lEFTSHIFT additiveexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														LeftShiftExpression,
														"LeftShiftExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_lEFTSHIFT.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_additiveexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 2 :
						// ../rsc/CSharp.g3:900:9: rIGHTSHIFT additiveexpression
							{
								pushFollow(FOLLOW_rIGHTSHIFT_in_shiftexpression5081);
								rIGHTSHIFT367 = rIGHTSHIFT();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_rIGHTSHIFT.add(rIGHTSHIFT367
										.getTree());
								pushFollow(FOLLOW_additiveexpression_in_shiftexpression5083);
								additiveexpression368 = additiveexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_additiveexpression
										.add(additiveexpression368.getTree());

								// AST REWRITE
								// elements: rIGHTSHIFT, shiftexpression, additiveexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 900:39: -> ^( RightShiftExpression $shiftexpression rIGHTSHIFT additiveexpression )
									{
										// ../rsc/CSharp.g3:900:42: ^( RightShiftExpression $shiftexpression rIGHTSHIFT additiveexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor
													.becomeRoot(
														(Object) this.adaptor
															.create(
																RightShiftExpression,
																"RightShiftExpression"),
														root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_rIGHTSHIFT.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_additiveexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "shiftexpression"

	public static class relationalexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "relationalexpression"
	// ../rsc/CSharp.g3:904:1: relationalexpression : ( shiftexpression -> shiftexpression ) ( lT shiftexpression -> ^( LessExpression $relationalexpression lT shiftexpression ) | gT shiftexpression -> ^( GreaterExpression $relationalexpression gT shiftexpression ) | lE shiftexpression -> ^( LessEqualExpression $relationalexpression lE shiftexpression ) | gE shiftexpression -> ^( GreaterEqualExpression $relationalexpression gE shiftexpression ) | iS type -> ^( IsExpression $relationalexpression iS shiftexpression ) | aS type -> ^( AsExpression $relationalexpression aS shiftexpression ) )* ;
	public final CSharpParser.relationalexpression_return relationalexpression()
			throws RecognitionException {
		CSharpParser.relationalexpression_return retval =
			new CSharpParser.relationalexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.shiftexpression_return shiftexpression369 = null;

		CSharpParser.lT_return lT370 = null;

		CSharpParser.shiftexpression_return shiftexpression371 = null;

		CSharpParser.gT_return gT372 = null;

		CSharpParser.shiftexpression_return shiftexpression373 = null;

		CSharpParser.lE_return lE374 = null;

		CSharpParser.shiftexpression_return shiftexpression375 = null;

		CSharpParser.gE_return gE376 = null;

		CSharpParser.shiftexpression_return shiftexpression377 = null;

		CSharpParser.iS_return iS378 = null;

		CSharpParser.type_return type379 = null;

		CSharpParser.aS_return aS380 = null;

		CSharpParser.type_return type381 = null;

		RewriteRuleSubtreeStream stream_iS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule iS");
		RewriteRuleSubtreeStream stream_lT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lT");
		RewriteRuleSubtreeStream stream_lE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lE");
		RewriteRuleSubtreeStream stream_gT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gT");
		RewriteRuleSubtreeStream stream_aS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aS");
		RewriteRuleSubtreeStream stream_gE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gE");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_shiftexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule shiftexpression");
		try {
			// ../rsc/CSharp.g3:905:5: ( ( shiftexpression -> shiftexpression ) ( lT shiftexpression -> ^( LessExpression $relationalexpression lT shiftexpression ) | gT shiftexpression -> ^( GreaterExpression $relationalexpression gT shiftexpression ) | lE shiftexpression -> ^( LessEqualExpression $relationalexpression lE shiftexpression ) | gE shiftexpression -> ^( GreaterEqualExpression $relationalexpression gE shiftexpression ) | iS type -> ^( IsExpression $relationalexpression iS shiftexpression ) | aS type -> ^( AsExpression $relationalexpression aS shiftexpression ) )* )
			// ../rsc/CSharp.g3:905:9: ( shiftexpression -> shiftexpression ) ( lT shiftexpression -> ^( LessExpression $relationalexpression lT shiftexpression ) | gT shiftexpression -> ^( GreaterExpression $relationalexpression gT shiftexpression ) | lE shiftexpression -> ^( LessEqualExpression $relationalexpression lE shiftexpression ) | gE shiftexpression -> ^( GreaterEqualExpression $relationalexpression gE shiftexpression ) | iS type -> ^( IsExpression $relationalexpression iS shiftexpression ) | aS type -> ^( AsExpression $relationalexpression aS shiftexpression ) )*
			{
				// ../rsc/CSharp.g3:905:9: ( shiftexpression -> shiftexpression )
				// ../rsc/CSharp.g3:905:10: shiftexpression
				{
					pushFollow(FOLLOW_shiftexpression_in_relationalexpression5129);
					shiftexpression369 = shiftexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_shiftexpression
							.add(shiftexpression369.getTree());

					// AST REWRITE
					// elements: shiftexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 905:26: -> shiftexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_shiftexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:906:9: ( lT shiftexpression -> ^( LessExpression $relationalexpression lT shiftexpression ) | gT shiftexpression -> ^( GreaterExpression $relationalexpression gT shiftexpression ) | lE shiftexpression -> ^( LessEqualExpression $relationalexpression lE shiftexpression ) | gE shiftexpression -> ^( GreaterEqualExpression $relationalexpression gE shiftexpression ) | iS type -> ^( IsExpression $relationalexpression iS shiftexpression ) | aS type -> ^( AsExpression $relationalexpression aS shiftexpression ) )*
				loop72: do {
					int alt72 = 7;
					switch (this.input.LA(1)) {
						case LT :
							{
								alt72 = 1;
							}
							break;
						case GT :
							{
								int LA72_3 = this.input.LA(2);

								if ((LA72_3 == ASSIGN)) {
									alt72 = 4;
								}
								else if (((LA72_3 >= Whitespace && LA72_3 <= Preprocessordirective)
										|| LA72_3 == LPAREN
										|| (LA72_3 >= PLUS && LA72_3 <= MINUS)
										|| (LA72_3 >= EXCLAM && LA72_3 <= TILDE)
										|| (LA72_3 >= INCREMENT && LA72_3 <= DECREMENT)
										|| (LA72_3 >= BASE && LA72_3 <= BOOL)
										|| LA72_3 == BYTE
										|| (LA72_3 >= CHAR && LA72_3 <= CHECKED)
										|| (LA72_3 >= DECIMAL && LA72_3 <= DELEGATE)
										|| LA72_3 == DOUBLE
										|| LA72_3 == FALSE
										|| LA72_3 == FLOAT
										|| LA72_3 == INT
										|| LA72_3 == LONG
										|| (LA72_3 >= NEW && LA72_3 <= OBJECT)
										|| LA72_3 == SBYTE
										|| LA72_3 == SHORT
										|| LA72_3 == STRING
										|| LA72_3 == THIS
										|| LA72_3 == TRUE
										|| (LA72_3 >= TYPEOF && LA72_3 <= UNCHECKED)
										|| LA72_3 == USHORT || (LA72_3 >= ADD && LA72_3 <= Stringliteral))) {
									alt72 = 2;
								}

							}
							break;
						case LE :
							{
								alt72 = 3;
							}
							break;
						case IS :
							{
								alt72 = 5;
							}
							break;
						case AS :
							{
								alt72 = 6;
							}
							break;

					}

					switch (alt72) {
						case 1 :
						// ../rsc/CSharp.g3:907:10: lT shiftexpression
							{
								pushFollow(FOLLOW_lT_in_relationalexpression5155);
								lT370 = lT();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_lT.add(lT370.getTree());
								pushFollow(FOLLOW_shiftexpression_in_relationalexpression5157);
								shiftexpression371 = shiftexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_shiftexpression
										.add(shiftexpression371.getTree());

								// AST REWRITE
								// elements: shiftexpression, lT, relationalexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 907:30: -> ^( LessExpression $relationalexpression lT shiftexpression )
									{
										// ../rsc/CSharp.g3:907:33: ^( LessExpression $relationalexpression lT shiftexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														LessExpression,
														"LessExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_lT.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_shiftexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 2 :
						// ../rsc/CSharp.g3:908:12: gT shiftexpression
							{
								pushFollow(FOLLOW_gT_in_relationalexpression5184);
								gT372 = gT();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_gT.add(gT372.getTree());
								pushFollow(FOLLOW_shiftexpression_in_relationalexpression5186);
								shiftexpression373 = shiftexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_shiftexpression
										.add(shiftexpression373.getTree());

								// AST REWRITE
								// elements: relationalexpression, gT, shiftexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 908:32: -> ^( GreaterExpression $relationalexpression gT shiftexpression )
									{
										// ../rsc/CSharp.g3:908:35: ^( GreaterExpression $relationalexpression gT shiftexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														GreaterExpression,
														"GreaterExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_gT.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_shiftexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 3 :
						// ../rsc/CSharp.g3:909:12: lE shiftexpression
							{
								pushFollow(FOLLOW_lE_in_relationalexpression5213);
								lE374 = lE();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_lE.add(lE374.getTree());
								pushFollow(FOLLOW_shiftexpression_in_relationalexpression5215);
								shiftexpression375 = shiftexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_shiftexpression
										.add(shiftexpression375.getTree());

								// AST REWRITE
								// elements: shiftexpression, lE, relationalexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 909:32: -> ^( LessEqualExpression $relationalexpression lE shiftexpression )
									{
										// ../rsc/CSharp.g3:909:35: ^( LessEqualExpression $relationalexpression lE shiftexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														LessEqualExpression,
														"LessEqualExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_lE.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_shiftexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 4 :
						// ../rsc/CSharp.g3:910:12: gE shiftexpression
							{
								pushFollow(FOLLOW_gE_in_relationalexpression5242);
								gE376 = gE();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_gE.add(gE376.getTree());
								pushFollow(FOLLOW_shiftexpression_in_relationalexpression5244);
								shiftexpression377 = shiftexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_shiftexpression
										.add(shiftexpression377.getTree());

								// AST REWRITE
								// elements: shiftexpression, relationalexpression, gE
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 910:32: -> ^( GreaterEqualExpression $relationalexpression gE shiftexpression )
									{
										// ../rsc/CSharp.g3:910:35: ^( GreaterEqualExpression $relationalexpression gE shiftexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor
													.becomeRoot(
														(Object) this.adaptor
															.create(
																GreaterEqualExpression,
																"GreaterEqualExpression"),
														root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_gE.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_shiftexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 5 :
						// ../rsc/CSharp.g3:911:12: iS type
							{
								pushFollow(FOLLOW_iS_in_relationalexpression5271);
								iS378 = iS();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_iS.add(iS378.getTree());
								pushFollow(FOLLOW_type_in_relationalexpression5273);
								type379 = type();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_type.add(type379.getTree());

								// AST REWRITE
								// elements: relationalexpression, shiftexpression, iS
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 911:23: -> ^( IsExpression $relationalexpression iS shiftexpression )
									{
										// ../rsc/CSharp.g3:911:26: ^( IsExpression $relationalexpression iS shiftexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														IsExpression,
														"IsExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_iS.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_shiftexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 6 :
						// ../rsc/CSharp.g3:912:12: aS type
							{
								pushFollow(FOLLOW_aS_in_relationalexpression5302);
								aS380 = aS();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_aS.add(aS380.getTree());
								pushFollow(FOLLOW_type_in_relationalexpression5304);
								type381 = type();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_type.add(type381.getTree());

								// AST REWRITE
								// elements: aS, relationalexpression, shiftexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 912:23: -> ^( AsExpression $relationalexpression aS shiftexpression )
									{
										// ../rsc/CSharp.g3:912:26: ^( AsExpression $relationalexpression aS shiftexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														AsExpression,
														"AsExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_aS.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_shiftexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "relationalexpression"

	public static class equalityexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "equalityexpression"
	// ../rsc/CSharp.g3:916:1: equalityexpression : ( relationalexpression -> relationalexpression ) ( eQUALS relationalexpression -> ^( EqualsExpression $equalityexpression eQUALS relationalexpression ) | nOTEQUALS relationalexpression -> ^( NotEqualsExpression $equalityexpression nOTEQUALS relationalexpression ) )* ;
	public final CSharpParser.equalityexpression_return equalityexpression()
			throws RecognitionException {
		CSharpParser.equalityexpression_return retval =
			new CSharpParser.equalityexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.relationalexpression_return relationalexpression382 = null;

		CSharpParser.eQUALS_return eQUALS383 = null;

		CSharpParser.relationalexpression_return relationalexpression384 = null;

		CSharpParser.nOTEQUALS_return nOTEQUALS385 = null;

		CSharpParser.relationalexpression_return relationalexpression386 = null;

		RewriteRuleSubtreeStream stream_eQUALS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eQUALS");
		RewriteRuleSubtreeStream stream_nOTEQUALS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nOTEQUALS");
		RewriteRuleSubtreeStream stream_relationalexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule relationalexpression");
		try {
			// ../rsc/CSharp.g3:917:5: ( ( relationalexpression -> relationalexpression ) ( eQUALS relationalexpression -> ^( EqualsExpression $equalityexpression eQUALS relationalexpression ) | nOTEQUALS relationalexpression -> ^( NotEqualsExpression $equalityexpression nOTEQUALS relationalexpression ) )* )
			// ../rsc/CSharp.g3:917:9: ( relationalexpression -> relationalexpression ) ( eQUALS relationalexpression -> ^( EqualsExpression $equalityexpression eQUALS relationalexpression ) | nOTEQUALS relationalexpression -> ^( NotEqualsExpression $equalityexpression nOTEQUALS relationalexpression ) )*
			{
				// ../rsc/CSharp.g3:917:9: ( relationalexpression -> relationalexpression )
				// ../rsc/CSharp.g3:917:10: relationalexpression
				{
					pushFollow(FOLLOW_relationalexpression_in_equalityexpression5352);
					relationalexpression382 = relationalexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_relationalexpression.add(relationalexpression382
							.getTree());

					// AST REWRITE
					// elements: relationalexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 917:31: -> relationalexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_relationalexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:918:6: ( eQUALS relationalexpression -> ^( EqualsExpression $equalityexpression eQUALS relationalexpression ) | nOTEQUALS relationalexpression -> ^( NotEqualsExpression $equalityexpression nOTEQUALS relationalexpression ) )*
				loop73: do {
					int alt73 = 3;
					int LA73_0 = this.input.LA(1);

					if ((LA73_0 == EQUALS)) {
						alt73 = 1;
					}
					else if ((LA73_0 == NOTEQUALS)) {
						alt73 = 2;
					}

					switch (alt73) {
						case 1 :
						// ../rsc/CSharp.g3:919:7: eQUALS relationalexpression
							{
								pushFollow(FOLLOW_eQUALS_in_equalityexpression5372);
								eQUALS383 = eQUALS();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_eQUALS.add(eQUALS383.getTree());
								pushFollow(FOLLOW_relationalexpression_in_equalityexpression5374);
								relationalexpression384 =
									relationalexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_relationalexpression
										.add(relationalexpression384.getTree());

								// AST REWRITE
								// elements: relationalexpression, eQUALS, equalityexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 919:36: -> ^( EqualsExpression $equalityexpression eQUALS relationalexpression )
									{
										// ../rsc/CSharp.g3:919:39: ^( EqualsExpression $equalityexpression eQUALS relationalexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														EqualsExpression,
														"EqualsExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_eQUALS.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_relationalexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;
						case 2 :
						// ../rsc/CSharp.g3:920:9: nOTEQUALS relationalexpression
							{
								pushFollow(FOLLOW_nOTEQUALS_in_equalityexpression5398);
								nOTEQUALS385 = nOTEQUALS();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_nOTEQUALS
										.add(nOTEQUALS385.getTree());
								pushFollow(FOLLOW_relationalexpression_in_equalityexpression5400);
								relationalexpression386 =
									relationalexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_relationalexpression
										.add(relationalexpression386.getTree());

								// AST REWRITE
								// elements: nOTEQUALS, equalityexpression, relationalexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 920:40: -> ^( NotEqualsExpression $equalityexpression nOTEQUALS relationalexpression )
									{
										// ../rsc/CSharp.g3:920:43: ^( NotEqualsExpression $equalityexpression nOTEQUALS relationalexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														NotEqualsExpression,
														"NotEqualsExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_nOTEQUALS.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_relationalexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "equalityexpression"

	public static class andexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "andexpression"
	// ../rsc/CSharp.g3:924:1: andexpression : ( equalityexpression -> equalityexpression ) ( aMPERSAND equalityexpression -> ^( BitwiseAndExpression $andexpression aMPERSAND equalityexpression ) )* ;
	public final CSharpParser.andexpression_return andexpression()
			throws RecognitionException {
		CSharpParser.andexpression_return retval =
			new CSharpParser.andexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.equalityexpression_return equalityexpression387 = null;

		CSharpParser.aMPERSAND_return aMPERSAND388 = null;

		CSharpParser.equalityexpression_return equalityexpression389 = null;

		RewriteRuleSubtreeStream stream_aMPERSAND =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aMPERSAND");
		RewriteRuleSubtreeStream stream_equalityexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule equalityexpression");
		try {
			// ../rsc/CSharp.g3:925:5: ( ( equalityexpression -> equalityexpression ) ( aMPERSAND equalityexpression -> ^( BitwiseAndExpression $andexpression aMPERSAND equalityexpression ) )* )
			// ../rsc/CSharp.g3:925:9: ( equalityexpression -> equalityexpression ) ( aMPERSAND equalityexpression -> ^( BitwiseAndExpression $andexpression aMPERSAND equalityexpression ) )*
			{
				// ../rsc/CSharp.g3:925:9: ( equalityexpression -> equalityexpression )
				// ../rsc/CSharp.g3:925:10: equalityexpression
				{
					pushFollow(FOLLOW_equalityexpression_in_andexpression5442);
					equalityexpression387 = equalityexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_equalityexpression.add(equalityexpression387
							.getTree());

					// AST REWRITE
					// elements: equalityexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 925:29: -> equalityexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_equalityexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:926:6: ( aMPERSAND equalityexpression -> ^( BitwiseAndExpression $andexpression aMPERSAND equalityexpression ) )*
				loop74: do {
					int alt74 = 2;
					int LA74_0 = this.input.LA(1);

					if ((LA74_0 == AMPERSAND)) {
						alt74 = 1;
					}

					switch (alt74) {
						case 1 :
						// ../rsc/CSharp.g3:926:7: aMPERSAND equalityexpression
							{
								pushFollow(FOLLOW_aMPERSAND_in_andexpression5455);
								aMPERSAND388 = aMPERSAND();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_aMPERSAND
										.add(aMPERSAND388.getTree());
								pushFollow(FOLLOW_equalityexpression_in_andexpression5457);
								equalityexpression389 = equalityexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_equalityexpression
										.add(equalityexpression389.getTree());

								// AST REWRITE
								// elements: aMPERSAND, andexpression, equalityexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 926:37: -> ^( BitwiseAndExpression $andexpression aMPERSAND equalityexpression )
									{
										// ../rsc/CSharp.g3:926:40: ^( BitwiseAndExpression $andexpression aMPERSAND equalityexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor
													.becomeRoot(
														(Object) this.adaptor
															.create(
																BitwiseAndExpression,
																"BitwiseAndExpression"),
														root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_aMPERSAND.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_equalityexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "andexpression"

	public static class exclusiveorexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "exclusiveorexpression"
	// ../rsc/CSharp.g3:930:1: exclusiveorexpression : ( andexpression -> andexpression ) ( bITWISEXOR andexpression -> ^( BitwiseXorExpression $exclusiveorexpression bITWISEXOR andexpression ) )* ;
	public final CSharpParser.exclusiveorexpression_return exclusiveorexpression()
			throws RecognitionException {
		CSharpParser.exclusiveorexpression_return retval =
			new CSharpParser.exclusiveorexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.andexpression_return andexpression390 = null;

		CSharpParser.bITWISEXOR_return bITWISEXOR391 = null;

		CSharpParser.andexpression_return andexpression392 = null;

		RewriteRuleSubtreeStream stream_andexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule andexpression");
		RewriteRuleSubtreeStream stream_bITWISEXOR =
			new RewriteRuleSubtreeStream(this.adaptor, "rule bITWISEXOR");
		try {
			// ../rsc/CSharp.g3:931:5: ( ( andexpression -> andexpression ) ( bITWISEXOR andexpression -> ^( BitwiseXorExpression $exclusiveorexpression bITWISEXOR andexpression ) )* )
			// ../rsc/CSharp.g3:931:9: ( andexpression -> andexpression ) ( bITWISEXOR andexpression -> ^( BitwiseXorExpression $exclusiveorexpression bITWISEXOR andexpression ) )*
			{
				// ../rsc/CSharp.g3:931:9: ( andexpression -> andexpression )
				// ../rsc/CSharp.g3:931:10: andexpression
				{
					pushFollow(FOLLOW_andexpression_in_exclusiveorexpression5500);
					andexpression390 = andexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_andexpression.add(andexpression390.getTree());

					// AST REWRITE
					// elements: andexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 931:24: -> andexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_andexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:932:6: ( bITWISEXOR andexpression -> ^( BitwiseXorExpression $exclusiveorexpression bITWISEXOR andexpression ) )*
				loop75: do {
					int alt75 = 2;
					int LA75_0 = this.input.LA(1);

					if ((LA75_0 == BITWISEXOR)) {
						alt75 = 1;
					}

					switch (alt75) {
						case 1 :
						// ../rsc/CSharp.g3:932:7: bITWISEXOR andexpression
							{
								pushFollow(FOLLOW_bITWISEXOR_in_exclusiveorexpression5513);
								bITWISEXOR391 = bITWISEXOR();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_bITWISEXOR.add(bITWISEXOR391
										.getTree());
								pushFollow(FOLLOW_andexpression_in_exclusiveorexpression5515);
								andexpression392 = andexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_andexpression.add(andexpression392
										.getTree());

								// AST REWRITE
								// elements: bITWISEXOR, exclusiveorexpression, andexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 932:32: -> ^( BitwiseXorExpression $exclusiveorexpression bITWISEXOR andexpression )
									{
										// ../rsc/CSharp.g3:932:35: ^( BitwiseXorExpression $exclusiveorexpression bITWISEXOR andexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor
													.becomeRoot(
														(Object) this.adaptor
															.create(
																BitwiseXorExpression,
																"BitwiseXorExpression"),
														root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_bITWISEXOR.nextTree());
											this.adaptor
												.addChild(
													root_1,
													stream_andexpression
														.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "exclusiveorexpression"

	public static class inclusiveorexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "inclusiveorexpression"
	// ../rsc/CSharp.g3:936:1: inclusiveorexpression : ( exclusiveorexpression -> exclusiveorexpression ) ( bITWISEOR exclusiveorexpression -> ^( BitwiseOrExpression $inclusiveorexpression bITWISEOR exclusiveorexpression ) )* ;
	public final CSharpParser.inclusiveorexpression_return inclusiveorexpression()
			throws RecognitionException {
		CSharpParser.inclusiveorexpression_return retval =
			new CSharpParser.inclusiveorexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.exclusiveorexpression_return exclusiveorexpression393 =
			null;

		CSharpParser.bITWISEOR_return bITWISEOR394 = null;

		CSharpParser.exclusiveorexpression_return exclusiveorexpression395 =
			null;

		RewriteRuleSubtreeStream stream_exclusiveorexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule exclusiveorexpression");
		RewriteRuleSubtreeStream stream_bITWISEOR =
			new RewriteRuleSubtreeStream(this.adaptor, "rule bITWISEOR");
		try {
			// ../rsc/CSharp.g3:937:5: ( ( exclusiveorexpression -> exclusiveorexpression ) ( bITWISEOR exclusiveorexpression -> ^( BitwiseOrExpression $inclusiveorexpression bITWISEOR exclusiveorexpression ) )* )
			// ../rsc/CSharp.g3:937:9: ( exclusiveorexpression -> exclusiveorexpression ) ( bITWISEOR exclusiveorexpression -> ^( BitwiseOrExpression $inclusiveorexpression bITWISEOR exclusiveorexpression ) )*
			{
				// ../rsc/CSharp.g3:937:9: ( exclusiveorexpression -> exclusiveorexpression )
				// ../rsc/CSharp.g3:937:10: exclusiveorexpression
				{
					pushFollow(FOLLOW_exclusiveorexpression_in_inclusiveorexpression5557);
					exclusiveorexpression393 = exclusiveorexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_exclusiveorexpression
							.add(exclusiveorexpression393.getTree());

					// AST REWRITE
					// elements: exclusiveorexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 937:32: -> exclusiveorexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_exclusiveorexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:938:6: ( bITWISEOR exclusiveorexpression -> ^( BitwiseOrExpression $inclusiveorexpression bITWISEOR exclusiveorexpression ) )*
				loop76: do {
					int alt76 = 2;
					int LA76_0 = this.input.LA(1);

					if ((LA76_0 == BITWISEOR)) {
						alt76 = 1;
					}

					switch (alt76) {
						case 1 :
						// ../rsc/CSharp.g3:938:7: bITWISEOR exclusiveorexpression
							{
								pushFollow(FOLLOW_bITWISEOR_in_inclusiveorexpression5570);
								bITWISEOR394 = bITWISEOR();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_bITWISEOR
										.add(bITWISEOR394.getTree());
								pushFollow(FOLLOW_exclusiveorexpression_in_inclusiveorexpression5572);
								exclusiveorexpression395 =
									exclusiveorexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_exclusiveorexpression
										.add(exclusiveorexpression395.getTree());

								// AST REWRITE
								// elements: exclusiveorexpression, bITWISEOR, inclusiveorexpression
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 938:39: -> ^( BitwiseOrExpression $inclusiveorexpression bITWISEOR exclusiveorexpression )
									{
										// ../rsc/CSharp.g3:938:42: ^( BitwiseOrExpression $inclusiveorexpression bITWISEOR exclusiveorexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														BitwiseOrExpression,
														"BitwiseOrExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_bITWISEOR.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_exclusiveorexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "inclusiveorexpression"

	public static class conditionalandexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "conditionalandexpression"
	// ../rsc/CSharp.g3:942:1: conditionalandexpression : ( inclusiveorexpression -> inclusiveorexpression ) ( lOGICALAND inclusiveorexpression -> ^( AndExpression $conditionalandexpression lOGICALAND inclusiveorexpression ) )* ;
	public final CSharpParser.conditionalandexpression_return conditionalandexpression()
			throws RecognitionException {
		CSharpParser.conditionalandexpression_return retval =
			new CSharpParser.conditionalandexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.inclusiveorexpression_return inclusiveorexpression396 =
			null;

		CSharpParser.lOGICALAND_return lOGICALAND397 = null;

		CSharpParser.inclusiveorexpression_return inclusiveorexpression398 =
			null;

		RewriteRuleSubtreeStream stream_inclusiveorexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule inclusiveorexpression");
		RewriteRuleSubtreeStream stream_lOGICALAND =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lOGICALAND");
		try {
			// ../rsc/CSharp.g3:943:2: ( ( inclusiveorexpression -> inclusiveorexpression ) ( lOGICALAND inclusiveorexpression -> ^( AndExpression $conditionalandexpression lOGICALAND inclusiveorexpression ) )* )
			// ../rsc/CSharp.g3:943:4: ( inclusiveorexpression -> inclusiveorexpression ) ( lOGICALAND inclusiveorexpression -> ^( AndExpression $conditionalandexpression lOGICALAND inclusiveorexpression ) )*
			{
				// ../rsc/CSharp.g3:943:4: ( inclusiveorexpression -> inclusiveorexpression )
				// ../rsc/CSharp.g3:943:5: inclusiveorexpression
				{
					pushFollow(FOLLOW_inclusiveorexpression_in_conditionalandexpression5609);
					inclusiveorexpression396 = inclusiveorexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_inclusiveorexpression
							.add(inclusiveorexpression396.getTree());

					// AST REWRITE
					// elements: inclusiveorexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 943:27: -> inclusiveorexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_inclusiveorexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:944:3: ( lOGICALAND inclusiveorexpression -> ^( AndExpression $conditionalandexpression lOGICALAND inclusiveorexpression ) )*
				loop77: do {
					int alt77 = 2;
					int LA77_0 = this.input.LA(1);

					if ((LA77_0 == LOGICALAND)) {
						alt77 = 1;
					}

					switch (alt77) {
						case 1 :
						// ../rsc/CSharp.g3:944:4: lOGICALAND inclusiveorexpression
							{
								pushFollow(FOLLOW_lOGICALAND_in_conditionalandexpression5619);
								lOGICALAND397 = lOGICALAND();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_lOGICALAND.add(lOGICALAND397
										.getTree());
								pushFollow(FOLLOW_inclusiveorexpression_in_conditionalandexpression5621);
								inclusiveorexpression398 =
									inclusiveorexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_inclusiveorexpression
										.add(inclusiveorexpression398.getTree());

								// AST REWRITE
								// elements: conditionalandexpression, inclusiveorexpression, lOGICALAND
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 944:37: -> ^( AndExpression $conditionalandexpression lOGICALAND inclusiveorexpression )
									{
										// ../rsc/CSharp.g3:944:40: ^( AndExpression $conditionalandexpression lOGICALAND inclusiveorexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														AndExpression,
														"AndExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_lOGICALAND.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_inclusiveorexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "conditionalandexpression"

	public static class conditionalorexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "conditionalorexpression"
	// ../rsc/CSharp.g3:948:1: conditionalorexpression : ( conditionalandexpression -> conditionalandexpression ) ( lOGICALOR conditionalandexpression -> ^( OrExpression $conditionalorexpression lOGICALOR conditionalandexpression ) )* ;
	public final CSharpParser.conditionalorexpression_return conditionalorexpression()
			throws RecognitionException {
		CSharpParser.conditionalorexpression_return retval =
			new CSharpParser.conditionalorexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.conditionalandexpression_return conditionalandexpression399 =
			null;

		CSharpParser.lOGICALOR_return lOGICALOR400 = null;

		CSharpParser.conditionalandexpression_return conditionalandexpression401 =
			null;

		RewriteRuleSubtreeStream stream_lOGICALOR =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lOGICALOR");
		RewriteRuleSubtreeStream stream_conditionalandexpression =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule conditionalandexpression");
		try {
			// ../rsc/CSharp.g3:949:5: ( ( conditionalandexpression -> conditionalandexpression ) ( lOGICALOR conditionalandexpression -> ^( OrExpression $conditionalorexpression lOGICALOR conditionalandexpression ) )* )
			// ../rsc/CSharp.g3:949:9: ( conditionalandexpression -> conditionalandexpression ) ( lOGICALOR conditionalandexpression -> ^( OrExpression $conditionalorexpression lOGICALOR conditionalandexpression ) )*
			{
				// ../rsc/CSharp.g3:949:9: ( conditionalandexpression -> conditionalandexpression )
				// ../rsc/CSharp.g3:949:10: conditionalandexpression
				{
					pushFollow(FOLLOW_conditionalandexpression_in_conditionalorexpression5660);
					conditionalandexpression399 = conditionalandexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_conditionalandexpression
							.add(conditionalandexpression399.getTree());

					// AST REWRITE
					// elements: conditionalandexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 949:35: -> conditionalandexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_conditionalandexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:950:6: ( lOGICALOR conditionalandexpression -> ^( OrExpression $conditionalorexpression lOGICALOR conditionalandexpression ) )*
				loop78: do {
					int alt78 = 2;
					int LA78_0 = this.input.LA(1);

					if ((LA78_0 == LOGICALOR)) {
						alt78 = 1;
					}

					switch (alt78) {
						case 1 :
						// ../rsc/CSharp.g3:950:7: lOGICALOR conditionalandexpression
							{
								pushFollow(FOLLOW_lOGICALOR_in_conditionalorexpression5673);
								lOGICALOR400 = lOGICALOR();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_lOGICALOR
										.add(lOGICALOR400.getTree());
								pushFollow(FOLLOW_conditionalandexpression_in_conditionalorexpression5675);
								conditionalandexpression401 =
									conditionalandexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_conditionalandexpression
										.add(conditionalandexpression401
											.getTree());

								// AST REWRITE
								// elements: conditionalandexpression, conditionalorexpression, lOGICALOR
								// token labels: 
								// rule labels: retval
								// token list labels: 
								// rule list labels: 
								// wildcard labels: 
								if (this.state.backtracking == 0) {
									retval.tree = root_0;
									RewriteRuleSubtreeStream stream_retval =
										new RewriteRuleSubtreeStream(
											this.adaptor,
											"rule retval",
											retval != null ? retval.tree : null);

									root_0 = (Object) this.adaptor.nil();
									// 950:42: -> ^( OrExpression $conditionalorexpression lOGICALOR conditionalandexpression )
									{
										// ../rsc/CSharp.g3:950:45: ^( OrExpression $conditionalorexpression lOGICALOR conditionalandexpression )
										{
											Object root_1 =
												(Object) this.adaptor.nil();
											root_1 =
												(Object) this.adaptor.becomeRoot(
													(Object) this.adaptor.create(
														OrExpression,
														"OrExpression"),
													root_1);

											this.adaptor.addChild(
												root_1,
												stream_retval.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_lOGICALOR.nextTree());
											this.adaptor.addChild(
												root_1,
												stream_conditionalandexpression
													.nextTree());

											this.adaptor.addChild(root_0, root_1);
										}

									}

									retval.tree = root_0;
								}
							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "conditionalorexpression"

	public static class nullcoalescingexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "nullcoalescingexpression"
	// ../rsc/CSharp.g3:954:1: nullcoalescingexpression : ( conditionalorexpression -> conditionalorexpression ) ( dOUBLEQUESTION nullcoalescingexpression -> ^( NullCoalescingExpression conditionalorexpression dOUBLEQUESTION nullcoalescingexpression ) )? ;
	public final CSharpParser.nullcoalescingexpression_return nullcoalescingexpression()
			throws RecognitionException {
		CSharpParser.nullcoalescingexpression_return retval =
			new CSharpParser.nullcoalescingexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.conditionalorexpression_return conditionalorexpression402 =
			null;

		CSharpParser.dOUBLEQUESTION_return dOUBLEQUESTION403 = null;

		CSharpParser.nullcoalescingexpression_return nullcoalescingexpression404 =
			null;

		RewriteRuleSubtreeStream stream_nullcoalescingexpression =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule nullcoalescingexpression");
		RewriteRuleSubtreeStream stream_conditionalorexpression =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule conditionalorexpression");
		RewriteRuleSubtreeStream stream_dOUBLEQUESTION =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dOUBLEQUESTION");
		try {
			// ../rsc/CSharp.g3:955:5: ( ( conditionalorexpression -> conditionalorexpression ) ( dOUBLEQUESTION nullcoalescingexpression -> ^( NullCoalescingExpression conditionalorexpression dOUBLEQUESTION nullcoalescingexpression ) )? )
			// ../rsc/CSharp.g3:955:9: ( conditionalorexpression -> conditionalorexpression ) ( dOUBLEQUESTION nullcoalescingexpression -> ^( NullCoalescingExpression conditionalorexpression dOUBLEQUESTION nullcoalescingexpression ) )?
			{
				// ../rsc/CSharp.g3:955:9: ( conditionalorexpression -> conditionalorexpression )
				// ../rsc/CSharp.g3:955:10: conditionalorexpression
				{
					pushFollow(FOLLOW_conditionalorexpression_in_nullcoalescingexpression5716);
					conditionalorexpression402 = conditionalorexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_conditionalorexpression
							.add(conditionalorexpression402.getTree());

					// AST REWRITE
					// elements: conditionalorexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 955:34: -> conditionalorexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_conditionalorexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:957:6: ( dOUBLEQUESTION nullcoalescingexpression -> ^( NullCoalescingExpression conditionalorexpression dOUBLEQUESTION nullcoalescingexpression ) )?
				int alt79 = 2;
				int LA79_0 = this.input.LA(1);

				if ((LA79_0 == DOUBLEQUESTION)) {
					alt79 = 1;
				}
				switch (alt79) {
					case 1 :
					// ../rsc/CSharp.g3:957:7: dOUBLEQUESTION nullcoalescingexpression
						{
							pushFollow(FOLLOW_dOUBLEQUESTION_in_nullcoalescingexpression5735);
							dOUBLEQUESTION403 = dOUBLEQUESTION();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_dOUBLEQUESTION.add(dOUBLEQUESTION403
									.getTree());
							pushFollow(FOLLOW_nullcoalescingexpression_in_nullcoalescingexpression5737);
							nullcoalescingexpression404 =
								nullcoalescingexpression();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_nullcoalescingexpression
									.add(nullcoalescingexpression404.getTree());

							// AST REWRITE
							// elements: nullcoalescingexpression, conditionalorexpression, dOUBLEQUESTION
							// token labels: 
							// rule labels: retval
							// token list labels: 
							// rule list labels: 
							// wildcard labels: 
							if (this.state.backtracking == 0) {
								retval.tree = root_0;
								new RewriteRuleSubtreeStream(
									this.adaptor,
									"rule retval",
									retval != null ? retval.tree : null);

								root_0 = (Object) this.adaptor.nil();
								// 958:9: -> ^( NullCoalescingExpression conditionalorexpression dOUBLEQUESTION nullcoalescingexpression )
								{
									// ../rsc/CSharp.g3:958:12: ^( NullCoalescingExpression conditionalorexpression dOUBLEQUESTION nullcoalescingexpression )
									{
										Object root_1 = (Object) this.adaptor.nil();
										root_1 =
											(Object) this.adaptor
												.becomeRoot(
													(Object) this.adaptor
														.create(
															NullCoalescingExpression,
															"NullCoalescingExpression"),
													root_1);

										this.adaptor.addChild(
											root_1,
											stream_conditionalorexpression
												.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_dOUBLEQUESTION.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_nullcoalescingexpression
												.nextTree());

										this.adaptor.addChild(root_0, root_1);
									}

								}

								retval.tree = root_0;
							}
						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "nullcoalescingexpression"

	public static class conditionalexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "conditionalexpression"
	// ../rsc/CSharp.g3:963:1: conditionalexpression : ( nullcoalescingexpression -> nullcoalescingexpression ) ( qUESTION expression cOLON expression -> ^( ConditionalExpression nullcoalescingexpression qUESTION expression cOLON expression ) )? ;
	public final CSharpParser.conditionalexpression_return conditionalexpression()
			throws RecognitionException {
		CSharpParser.conditionalexpression_return retval =
			new CSharpParser.conditionalexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nullcoalescingexpression_return nullcoalescingexpression405 =
			null;

		CSharpParser.qUESTION_return qUESTION406 = null;

		CSharpParser.expression_return expression407 = null;

		CSharpParser.cOLON_return cOLON408 = null;

		CSharpParser.expression_return expression409 = null;

		RewriteRuleSubtreeStream stream_qUESTION =
			new RewriteRuleSubtreeStream(this.adaptor, "rule qUESTION");
		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_cOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOLON");
		RewriteRuleSubtreeStream stream_nullcoalescingexpression =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule nullcoalescingexpression");
		try {
			// ../rsc/CSharp.g3:964:5: ( ( nullcoalescingexpression -> nullcoalescingexpression ) ( qUESTION expression cOLON expression -> ^( ConditionalExpression nullcoalescingexpression qUESTION expression cOLON expression ) )? )
			// ../rsc/CSharp.g3:964:9: ( nullcoalescingexpression -> nullcoalescingexpression ) ( qUESTION expression cOLON expression -> ^( ConditionalExpression nullcoalescingexpression qUESTION expression cOLON expression ) )?
			{
				// ../rsc/CSharp.g3:964:9: ( nullcoalescingexpression -> nullcoalescingexpression )
				// ../rsc/CSharp.g3:964:10: nullcoalescingexpression
				{
					pushFollow(FOLLOW_nullcoalescingexpression_in_conditionalexpression5786);
					nullcoalescingexpression405 = nullcoalescingexpression();

					this.state._fsp--;
					if (this.state.failed)
						return retval;
					if (this.state.backtracking == 0)
						stream_nullcoalescingexpression
							.add(nullcoalescingexpression405.getTree());

					// AST REWRITE
					// elements: nullcoalescingexpression
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if (this.state.backtracking == 0) {
						retval.tree = root_0;
						new RewriteRuleSubtreeStream(
							this.adaptor,
							"rule retval",
							retval != null ? retval.tree : null);

						root_0 = (Object) this.adaptor.nil();
						// 964:35: -> nullcoalescingexpression
						{
							this.adaptor.addChild(
								root_0,
								stream_nullcoalescingexpression.nextTree());

						}

						retval.tree = root_0;
					}
				}

				// ../rsc/CSharp.g3:966:6: ( qUESTION expression cOLON expression -> ^( ConditionalExpression nullcoalescingexpression qUESTION expression cOLON expression ) )?
				int alt80 = 2;
				int LA80_0 = this.input.LA(1);

				if ((LA80_0 == QUESTION)) {
					alt80 = 1;
				}
				switch (alt80) {
					case 1 :
					// ../rsc/CSharp.g3:966:7: qUESTION expression cOLON expression
						{
							pushFollow(FOLLOW_qUESTION_in_conditionalexpression5808);
							qUESTION406 = qUESTION();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_qUESTION.add(qUESTION406.getTree());
							pushFollow(FOLLOW_expression_in_conditionalexpression5810);
							expression407 = expression();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_expression.add(expression407.getTree());
							pushFollow(FOLLOW_cOLON_in_conditionalexpression5812);
							cOLON408 = cOLON();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_cOLON.add(cOLON408.getTree());
							pushFollow(FOLLOW_expression_in_conditionalexpression5814);
							expression409 = expression();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_expression.add(expression409.getTree());

							// AST REWRITE
							// elements: expression, qUESTION, cOLON, expression, nullcoalescingexpression
							// token labels: 
							// rule labels: retval
							// token list labels: 
							// rule list labels: 
							// wildcard labels: 
							if (this.state.backtracking == 0) {
								retval.tree = root_0;
								new RewriteRuleSubtreeStream(
									this.adaptor,
									"rule retval",
									retval != null ? retval.tree : null);

								root_0 = (Object) this.adaptor.nil();
								// 967:6: -> ^( ConditionalExpression nullcoalescingexpression qUESTION expression cOLON expression )
								{
									// ../rsc/CSharp.g3:967:9: ^( ConditionalExpression nullcoalescingexpression qUESTION expression cOLON expression )
									{
										Object root_1 = (Object) this.adaptor.nil();
										root_1 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													ConditionalExpression,
													"ConditionalExpression"),
												root_1);

										this.adaptor.addChild(
											root_1,
											stream_nullcoalescingexpression
												.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_qUESTION.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_expression.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_cOLON.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_expression.nextTree());

										this.adaptor.addChild(root_0, root_1);
									}

								}

								retval.tree = root_0;
							}
						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "conditionalexpression"

	public static class assignment_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "assignment"
	// ../rsc/CSharp.g3:971:1: assignment : unaryexpression assignmentoperator expression -> ^( Assignment unaryexpression assignmentoperator expression ) ;
	public final CSharpParser.assignment_return assignment()
			throws RecognitionException {
		CSharpParser.assignment_return retval =
			new CSharpParser.assignment_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.unaryexpression_return unaryexpression410 = null;

		CSharpParser.assignmentoperator_return assignmentoperator411 = null;

		CSharpParser.expression_return expression412 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_unaryexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule unaryexpression");
		RewriteRuleSubtreeStream stream_assignmentoperator =
			new RewriteRuleSubtreeStream(this.adaptor, "rule assignmentoperator");
		try {
			// ../rsc/CSharp.g3:972:5: ( unaryexpression assignmentoperator expression -> ^( Assignment unaryexpression assignmentoperator expression ) )
			// ../rsc/CSharp.g3:972:9: unaryexpression assignmentoperator expression
			{
				pushFollow(FOLLOW_unaryexpression_in_assignment5862);
				unaryexpression410 = unaryexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_unaryexpression.add(unaryexpression410.getTree());
				pushFollow(FOLLOW_assignmentoperator_in_assignment5864);
				assignmentoperator411 = assignmentoperator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_assignmentoperator.add(assignmentoperator411
						.getTree());
				pushFollow(FOLLOW_expression_in_assignment5866);
				expression412 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression412.getTree());

				// AST REWRITE
				// elements: expression, assignmentoperator, unaryexpression
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 973:5: -> ^( Assignment unaryexpression assignmentoperator expression )
					{
						// ../rsc/CSharp.g3:973:8: ^( Assignment unaryexpression assignmentoperator expression )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Assignment, "Assignment"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_unaryexpression.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_assignmentoperator.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "assignment"

	public static class assignmentoperator_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "assignmentoperator"
	// ../rsc/CSharp.g3:977:1: assignmentoperator : ( aSSIGN | aDDASSIGN | sUBASSIGN | mULASSIGN | dIVASSIGN | mODASSIGN | bITWISEANDASSIGN | bITWISEORASSIGN | bITWISEXORASSIGN | lEFTSHIFTASSIGN | rIGHTSHIFTASSIGN );
	public final CSharpParser.assignmentoperator_return assignmentoperator()
			throws RecognitionException {
		CSharpParser.assignmentoperator_return retval =
			new CSharpParser.assignmentoperator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.aSSIGN_return aSSIGN413 = null;

		CSharpParser.aDDASSIGN_return aDDASSIGN414 = null;

		CSharpParser.sUBASSIGN_return sUBASSIGN415 = null;

		CSharpParser.mULASSIGN_return mULASSIGN416 = null;

		CSharpParser.dIVASSIGN_return dIVASSIGN417 = null;

		CSharpParser.mODASSIGN_return mODASSIGN418 = null;

		CSharpParser.bITWISEANDASSIGN_return bITWISEANDASSIGN419 = null;

		CSharpParser.bITWISEORASSIGN_return bITWISEORASSIGN420 = null;

		CSharpParser.bITWISEXORASSIGN_return bITWISEXORASSIGN421 = null;

		CSharpParser.lEFTSHIFTASSIGN_return lEFTSHIFTASSIGN422 = null;

		CSharpParser.rIGHTSHIFTASSIGN_return rIGHTSHIFTASSIGN423 = null;

		try {
			// ../rsc/CSharp.g3:978:5: ( aSSIGN | aDDASSIGN | sUBASSIGN | mULASSIGN | dIVASSIGN | mODASSIGN | bITWISEANDASSIGN | bITWISEORASSIGN | bITWISEXORASSIGN | lEFTSHIFTASSIGN | rIGHTSHIFTASSIGN )
			int alt81 = 11;
			switch (this.input.LA(1)) {
				case ASSIGN :
					{
						alt81 = 1;
					}
					break;
				case ADDASSIGN :
					{
						alt81 = 2;
					}
					break;
				case SUBASSIGN :
					{
						alt81 = 3;
					}
					break;
				case MULASSIGN :
					{
						alt81 = 4;
					}
					break;
				case DIVASSIGN :
					{
						alt81 = 5;
					}
					break;
				case MODASSIGN :
					{
						alt81 = 6;
					}
					break;
				case BITWISEANDASSIGN :
					{
						alt81 = 7;
					}
					break;
				case BITWISEORASSIGN :
					{
						alt81 = 8;
					}
					break;
				case BITWISEXORASSIGN :
					{
						alt81 = 9;
					}
					break;
				case LEFTSHIFTASSIGN :
					{
						alt81 = 10;
					}
					break;
				case GT :
					{
						alt81 = 11;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 81, 0, this.input);

					throw nvae;
			}

			switch (alt81) {
				case 1 :
				// ../rsc/CSharp.g3:978:10: aSSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aSSIGN_in_assignmentoperator5903);
						aSSIGN413 = aSSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aSSIGN413.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:978:19: aDDASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aDDASSIGN_in_assignmentoperator5907);
						aDDASSIGN414 = aDDASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aDDASSIGN414.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:978:31: sUBASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sUBASSIGN_in_assignmentoperator5911);
						sUBASSIGN415 = sUBASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sUBASSIGN415.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:978:43: mULASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_mULASSIGN_in_assignmentoperator5915);
						mULASSIGN416 = mULASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, mULASSIGN416.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:978:55: dIVASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dIVASSIGN_in_assignmentoperator5919);
						dIVASSIGN417 = dIVASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dIVASSIGN417.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:978:67: mODASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_mODASSIGN_in_assignmentoperator5923);
						mODASSIGN418 = mODASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, mODASSIGN418.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:979:10: bITWISEANDASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bITWISEANDASSIGN_in_assignmentoperator5934);
						bITWISEANDASSIGN419 = bITWISEANDASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								bITWISEANDASSIGN419.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:979:29: bITWISEORASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bITWISEORASSIGN_in_assignmentoperator5938);
						bITWISEORASSIGN420 = bITWISEORASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								bITWISEORASSIGN420.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:979:47: bITWISEXORASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bITWISEXORASSIGN_in_assignmentoperator5942);
						bITWISEXORASSIGN421 = bITWISEXORASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								bITWISEXORASSIGN421.getTree());

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:979:66: lEFTSHIFTASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lEFTSHIFTASSIGN_in_assignmentoperator5946);
						lEFTSHIFTASSIGN422 = lEFTSHIFTASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								lEFTSHIFTASSIGN422.getTree());

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:980:10: rIGHTSHIFTASSIGN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_rIGHTSHIFTASSIGN_in_assignmentoperator5957);
						rIGHTSHIFTASSIGN423 = rIGHTSHIFTASSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								rIGHTSHIFTASSIGN423.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "assignmentoperator"

	public static class expression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "expression"
	// ../rsc/CSharp.g3:984:1: expression options {memoize=true; } : ( assignment | conditionalexpression );
	public final CSharpParser.expression_return expression()
			throws RecognitionException {
		CSharpParser.expression_return retval =
			new CSharpParser.expression_return();
		retval.start = this.input.LT(1);
		int expression_StartIndex = this.input.index();
		Object root_0 = null;

		CSharpParser.assignment_return assignment424 = null;

		CSharpParser.conditionalexpression_return conditionalexpression425 =
			null;

		try {
			if (this.state.backtracking > 0 && alreadyParsedRule(this.input, 79)) {
				return retval;
			}
			// ../rsc/CSharp.g3:987:5: ( assignment | conditionalexpression )
			int alt82 = 2;
			alt82 = this.dfa82.predict(this.input);
			switch (alt82) {
				case 1 :
				// ../rsc/CSharp.g3:987:9: assignment
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_assignment_in_expression5990);
						assignment424 = assignment();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, assignment424.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:990:9: conditionalexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_conditionalexpression_in_expression6019);
						conditionalexpression425 = conditionalexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								conditionalexpression425.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
			if (this.state.backtracking > 0) {
				memoize(this.input, 79, expression_StartIndex);
			}
		}
		return retval;
	}
	// $ANTLR end "expression"

	public static class constantexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constantexpression"
	// ../rsc/CSharp.g3:993:1: constantexpression : expression -> ^( ConstantExpression expression ) ;
	public final CSharpParser.constantexpression_return constantexpression()
			throws RecognitionException {
		CSharpParser.constantexpression_return retval =
			new CSharpParser.constantexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.expression_return expression426 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		try {
			// ../rsc/CSharp.g3:994:5: ( expression -> ^( ConstantExpression expression ) )
			// ../rsc/CSharp.g3:994:9: expression
			{
				pushFollow(FOLLOW_expression_in_constantexpression6038);
				expression426 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression426.getTree());

				// AST REWRITE
				// elements: expression
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 995:5: -> ^( ConstantExpression expression )
					{
						// ../rsc/CSharp.g3:995:8: ^( ConstantExpression expression )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ConstantExpression,
										"ConstantExpression"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constantexpression"

	public static class booleanexpression_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "booleanexpression"
	// ../rsc/CSharp.g3:998:1: booleanexpression : expression -> ^( BooleanExpression expression ) ;
	public final CSharpParser.booleanexpression_return booleanexpression()
			throws RecognitionException {
		CSharpParser.booleanexpression_return retval =
			new CSharpParser.booleanexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.expression_return expression427 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		try {
			// ../rsc/CSharp.g3:999:5: ( expression -> ^( BooleanExpression expression ) )
			// ../rsc/CSharp.g3:999:9: expression
			{
				pushFollow(FOLLOW_expression_in_booleanexpression6069);
				expression427 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression427.getTree());

				// AST REWRITE
				// elements: expression
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1000:5: -> ^( BooleanExpression expression )
					{
						// ../rsc/CSharp.g3:1000:8: ^( BooleanExpression expression )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										BooleanExpression,
										"BooleanExpression"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "booleanexpression"

	public static class statement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "statement"
	// ../rsc/CSharp.g3:1005:1: statement : ( labeledstatement -> ^( Statement labeledstatement ) | declarationstatement -> ^( Statement declarationstatement ) | embeddedstatement -> ^( Statement embeddedstatement ) );
	public final CSharpParser.statement_return statement()
			throws RecognitionException {
		CSharpParser.statement_return retval =
			new CSharpParser.statement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.labeledstatement_return labeledstatement428 = null;

		CSharpParser.declarationstatement_return declarationstatement429 = null;

		CSharpParser.embeddedstatement_return embeddedstatement430 = null;

		RewriteRuleSubtreeStream stream_labeledstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule labeledstatement");
		RewriteRuleSubtreeStream stream_embeddedstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule embeddedstatement");
		RewriteRuleSubtreeStream stream_declarationstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule declarationstatement");
		try {
			// ../rsc/CSharp.g3:1006:5: ( labeledstatement -> ^( Statement labeledstatement ) | declarationstatement -> ^( Statement declarationstatement ) | embeddedstatement -> ^( Statement embeddedstatement ) )
			int alt83 = 3;
			alt83 = this.dfa83.predict(this.input);
			switch (alt83) {
				case 1 :
				// ../rsc/CSharp.g3:1006:9: labeledstatement
					{
						pushFollow(FOLLOW_labeledstatement_in_statement6102);
						labeledstatement428 = labeledstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_labeledstatement.add(labeledstatement428
								.getTree());

						// AST REWRITE
						// elements: labeledstatement
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1007:5: -> ^( Statement labeledstatement )
							{
								// ../rsc/CSharp.g3:1007:8: ^( Statement labeledstatement )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Statement,
												"Statement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_labeledstatement.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1008:9: declarationstatement
					{
						pushFollow(FOLLOW_declarationstatement_in_statement6124);
						declarationstatement429 = declarationstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_declarationstatement
								.add(declarationstatement429.getTree());

						// AST REWRITE
						// elements: declarationstatement
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1009:5: -> ^( Statement declarationstatement )
							{
								// ../rsc/CSharp.g3:1009:8: ^( Statement declarationstatement )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Statement,
												"Statement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_declarationstatement.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1010:9: embeddedstatement
					{
						pushFollow(FOLLOW_embeddedstatement_in_statement6146);
						embeddedstatement430 = embeddedstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_embeddedstatement.add(embeddedstatement430
								.getTree());

						// AST REWRITE
						// elements: embeddedstatement
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1011:5: -> ^( Statement embeddedstatement )
							{
								// ../rsc/CSharp.g3:1011:8: ^( Statement embeddedstatement )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Statement,
												"Statement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_embeddedstatement.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "statement"

	public static class embeddedstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "embeddedstatement"
	// ../rsc/CSharp.g3:1014:1: embeddedstatement : ( block | emptystatement | expressionstatement | selectionstatement | iterationstatement | jumpstatement | trystatement | checkedstatement | uncheckedstatement | lockstatement | usingstatement | yieldstatement );
	public final CSharpParser.embeddedstatement_return embeddedstatement()
			throws RecognitionException {
		CSharpParser.embeddedstatement_return retval =
			new CSharpParser.embeddedstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.block_return block431 = null;

		CSharpParser.emptystatement_return emptystatement432 = null;

		CSharpParser.expressionstatement_return expressionstatement433 = null;

		CSharpParser.selectionstatement_return selectionstatement434 = null;

		CSharpParser.iterationstatement_return iterationstatement435 = null;

		CSharpParser.jumpstatement_return jumpstatement436 = null;

		CSharpParser.trystatement_return trystatement437 = null;

		CSharpParser.checkedstatement_return checkedstatement438 = null;

		CSharpParser.uncheckedstatement_return uncheckedstatement439 = null;

		CSharpParser.lockstatement_return lockstatement440 = null;

		CSharpParser.usingstatement_return usingstatement441 = null;

		CSharpParser.yieldstatement_return yieldstatement442 = null;

		try {
			// ../rsc/CSharp.g3:1015:5: ( block | emptystatement | expressionstatement | selectionstatement | iterationstatement | jumpstatement | trystatement | checkedstatement | uncheckedstatement | lockstatement | usingstatement | yieldstatement )
			int alt84 = 12;
			alt84 = this.dfa84.predict(this.input);
			switch (alt84) {
				case 1 :
				// ../rsc/CSharp.g3:1015:9: block
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_block_in_embeddedstatement6177);
						block431 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, block431.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1016:9: emptystatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_emptystatement_in_embeddedstatement6187);
						emptystatement432 = emptystatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								emptystatement432.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1017:9: expressionstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_expressionstatement_in_embeddedstatement6197);
						expressionstatement433 = expressionstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								expressionstatement433.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1018:9: selectionstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_selectionstatement_in_embeddedstatement6207);
						selectionstatement434 = selectionstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								selectionstatement434.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1019:9: iterationstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iterationstatement_in_embeddedstatement6217);
						iterationstatement435 = iterationstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								iterationstatement435.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:1020:9: jumpstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_jumpstatement_in_embeddedstatement6227);
						jumpstatement436 = jumpstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor
								.addChild(root_0, jumpstatement436.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:1021:9: trystatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_trystatement_in_embeddedstatement6237);
						trystatement437 = trystatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, trystatement437.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:1022:9: checkedstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_checkedstatement_in_embeddedstatement6247);
						checkedstatement438 = checkedstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								checkedstatement438.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:1023:9: uncheckedstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_uncheckedstatement_in_embeddedstatement6257);
						uncheckedstatement439 = uncheckedstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								uncheckedstatement439.getTree());

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:1024:9: lockstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lockstatement_in_embeddedstatement6267);
						lockstatement440 = lockstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor
								.addChild(root_0, lockstatement440.getTree());

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:1025:9: usingstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_usingstatement_in_embeddedstatement6277);
						usingstatement441 = usingstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								usingstatement441.getTree());

					}
					break;
				case 12 :
				// ../rsc/CSharp.g3:1026:9: yieldstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_yieldstatement_in_embeddedstatement6287);
						yieldstatement442 = yieldstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								yieldstatement442.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "embeddedstatement"

	public static class block_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "block"
	// ../rsc/CSharp.g3:1029:1: block : lBRACE ( statementlist )? rBRACE -> ^( Block lBRACE ( statementlist )? rBRACE ) ;
	public final CSharpParser.block_return block() throws RecognitionException {
		CSharpParser.block_return retval = new CSharpParser.block_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACE_return lBRACE443 = null;

		CSharpParser.statementlist_return statementlist444 = null;

		CSharpParser.rBRACE_return rBRACE445 = null;

		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_statementlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule statementlist");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:1030:5: ( lBRACE ( statementlist )? rBRACE -> ^( Block lBRACE ( statementlist )? rBRACE ) )
			// ../rsc/CSharp.g3:1030:9: lBRACE ( statementlist )? rBRACE
			{
				pushFollow(FOLLOW_lBRACE_in_block6306);
				lBRACE443 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE443.getTree());
				// ../rsc/CSharp.g3:1030:16: ( statementlist )?
				int alt85 = 2;
				int LA85_0 = this.input.LA(1);

				if ((LA85_0 == LBRACE || LA85_0 == LPAREN
						|| (LA85_0 >= SEMICOLON && LA85_0 <= MINUS)
						|| (LA85_0 >= EXCLAM && LA85_0 <= TILDE)
						|| (LA85_0 >= INCREMENT && LA85_0 <= DECREMENT)
						|| (LA85_0 >= BASE && LA85_0 <= BYTE)
						|| (LA85_0 >= CHAR && LA85_0 <= CHECKED)
						|| (LA85_0 >= CONST && LA85_0 <= DOUBLE)
						|| LA85_0 == FALSE || (LA85_0 >= FLOAT && LA85_0 <= IF)
						|| LA85_0 == INT || (LA85_0 >= LOCK && LA85_0 <= LONG)
						|| (LA85_0 >= NEW && LA85_0 <= OBJECT)
						|| (LA85_0 >= RETURN && LA85_0 <= SBYTE)
						|| LA85_0 == SHORT || LA85_0 == STRING
						|| (LA85_0 >= SWITCH && LA85_0 <= UNCHECKED)
						|| (LA85_0 >= USHORT && LA85_0 <= USING) || (LA85_0 >= WHILE && LA85_0 <= Stringliteral))) {
					alt85 = 1;
				}
				switch (alt85) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: statementlist
						{
							pushFollow(FOLLOW_statementlist_in_block6308);
							statementlist444 = statementlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_statementlist.add(statementlist444
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rBRACE_in_block6311);
				rBRACE445 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE445.getTree());

				// AST REWRITE
				// elements: statementlist, lBRACE, rBRACE
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1031:5: -> ^( Block lBRACE ( statementlist )? rBRACE )
					{
						// ../rsc/CSharp.g3:1031:9: ^( Block lBRACE ( statementlist )? rBRACE )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Block, "Block"),
									root_1);

							this.adaptor.addChild(root_1, stream_lBRACE.nextTree());
							// ../rsc/CSharp.g3:1031:24: ( statementlist )?
							if (stream_statementlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_statementlist.nextTree());

							}
							stream_statementlist.reset();
							this.adaptor.addChild(root_1, stream_rBRACE.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "block"

	public static class statementlist_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "statementlist"
	// ../rsc/CSharp.g3:1034:1: statementlist : ( statement )+ -> ^( StatementList ( statement )+ ) ;
	public final CSharpParser.statementlist_return statementlist()
			throws RecognitionException {
		CSharpParser.statementlist_return retval =
			new CSharpParser.statementlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.statement_return statement446 = null;

		RewriteRuleSubtreeStream stream_statement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule statement");
		try {
			// ../rsc/CSharp.g3:1035:5: ( ( statement )+ -> ^( StatementList ( statement )+ ) )
			// ../rsc/CSharp.g3:1035:9: ( statement )+
			{
				// ../rsc/CSharp.g3:1035:9: ( statement )+
				int cnt86 = 0;
				loop86: do {
					int alt86 = 2;
					alt86 = this.dfa86.predict(this.input);
					switch (alt86) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: statement
							{
								pushFollow(FOLLOW_statement_in_statementlist6349);
								statement446 = statement();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_statement
										.add(statement446.getTree());

							}
							break;

						default :
							if (cnt86 >= 1)
								break loop86;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(86, this.input);
							throw eee;
					}
					cnt86++;
				}
				while (true);

				// AST REWRITE
				// elements: statement
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1036:5: -> ^( StatementList ( statement )+ )
					{
						// ../rsc/CSharp.g3:1036:8: ^( StatementList ( statement )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										StatementList,
										"StatementList"),
									root_1);

							if (!(stream_statement.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_statement.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_statement.nextTree());

							}
							stream_statement.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "statementlist"

	public static class emptystatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "emptystatement"
	// ../rsc/CSharp.g3:1039:1: emptystatement : sEMICOLON -> ^( EmptyStatement sEMICOLON ) ;
	public final CSharpParser.emptystatement_return emptystatement()
			throws RecognitionException {
		CSharpParser.emptystatement_return retval =
			new CSharpParser.emptystatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.sEMICOLON_return sEMICOLON447 = null;

		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1040:5: ( sEMICOLON -> ^( EmptyStatement sEMICOLON ) )
			// ../rsc/CSharp.g3:1040:9: sEMICOLON
			{
				pushFollow(FOLLOW_sEMICOLON_in_emptystatement6382);
				sEMICOLON447 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON447.getTree());

				// AST REWRITE
				// elements: sEMICOLON
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1041:5: -> ^( EmptyStatement sEMICOLON )
					{
						// ../rsc/CSharp.g3:1041:8: ^( EmptyStatement sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										EmptyStatement,
										"EmptyStatement"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "emptystatement"

	public static class labeledstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "labeledstatement"
	// ../rsc/CSharp.g3:1044:1: labeledstatement : identifier cOLON statement -> ^( LabeledStatement identifier cOLON statement ) ;
	public final CSharpParser.labeledstatement_return labeledstatement()
			throws RecognitionException {
		CSharpParser.labeledstatement_return retval =
			new CSharpParser.labeledstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier448 = null;

		CSharpParser.cOLON_return cOLON449 = null;

		CSharpParser.statement_return statement450 = null;

		RewriteRuleSubtreeStream stream_statement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule statement");
		RewriteRuleSubtreeStream stream_cOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOLON");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:1045:5: ( identifier cOLON statement -> ^( LabeledStatement identifier cOLON statement ) )
			// ../rsc/CSharp.g3:1045:9: identifier cOLON statement
			{
				pushFollow(FOLLOW_identifier_in_labeledstatement6413);
				identifier448 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier448.getTree());
				pushFollow(FOLLOW_cOLON_in_labeledstatement6415);
				cOLON449 = cOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cOLON.add(cOLON449.getTree());
				pushFollow(FOLLOW_statement_in_labeledstatement6417);
				statement450 = statement();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_statement.add(statement450.getTree());

				// AST REWRITE
				// elements: statement, cOLON, identifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1046:5: -> ^( LabeledStatement identifier cOLON statement )
					{
						// ../rsc/CSharp.g3:1046:8: ^( LabeledStatement identifier cOLON statement )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										LabeledStatement,
										"LabeledStatement"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							this.adaptor.addChild(root_1, stream_cOLON.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_statement.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "labeledstatement"

	public static class declarationstatement_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "declarationstatement"
	// ../rsc/CSharp.g3:1049:1: declarationstatement : ( localvariabledeclaration sEMICOLON -> ^( DeclarationStatement localvariabledeclaration sEMICOLON ) | localconstantdeclaration sEMICOLON -> ^( DeclarationStatement localconstantdeclaration sEMICOLON ) );
	public final CSharpParser.declarationstatement_return declarationstatement()
			throws RecognitionException {
		CSharpParser.declarationstatement_return retval =
			new CSharpParser.declarationstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.localvariabledeclaration_return localvariabledeclaration451 =
			null;

		CSharpParser.sEMICOLON_return sEMICOLON452 = null;

		CSharpParser.localconstantdeclaration_return localconstantdeclaration453 =
			null;

		CSharpParser.sEMICOLON_return sEMICOLON454 = null;

		RewriteRuleSubtreeStream stream_localconstantdeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule localconstantdeclaration");
		RewriteRuleSubtreeStream stream_localvariabledeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule localvariabledeclaration");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1050:5: ( localvariabledeclaration sEMICOLON -> ^( DeclarationStatement localvariabledeclaration sEMICOLON ) | localconstantdeclaration sEMICOLON -> ^( DeclarationStatement localconstantdeclaration sEMICOLON ) )
			int alt87 = 2;
			int LA87_0 = this.input.LA(1);

			if ((LA87_0 == BOOL || LA87_0 == BYTE || LA87_0 == CHAR
					|| LA87_0 == DECIMAL || LA87_0 == DOUBLE || LA87_0 == FLOAT
					|| LA87_0 == INT || LA87_0 == LONG || LA87_0 == OBJECT
					|| LA87_0 == SBYTE || LA87_0 == SHORT || LA87_0 == STRING
					|| (LA87_0 >= UINT && LA87_0 <= ULONG) || LA87_0 == USHORT || (LA87_0 >= ADD && LA87_0 <= Ident))) {
				alt87 = 1;
			}
			else if ((LA87_0 == CONST)) {
				alt87 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 87, 0, this.input);

				throw nvae;
			}
			switch (alt87) {
				case 1 :
				// ../rsc/CSharp.g3:1050:9: localvariabledeclaration sEMICOLON
					{
						pushFollow(FOLLOW_localvariabledeclaration_in_declarationstatement6452);
						localvariabledeclaration451 =
							localvariabledeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_localvariabledeclaration
								.add(localvariabledeclaration451.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_declarationstatement6454);
						sEMICOLON452 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON452.getTree());

						// AST REWRITE
						// elements: sEMICOLON, localvariabledeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1051:5: -> ^( DeclarationStatement localvariabledeclaration sEMICOLON )
							{
								// ../rsc/CSharp.g3:1051:8: ^( DeclarationStatement localvariabledeclaration sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												DeclarationStatement,
												"DeclarationStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_localvariabledeclaration
											.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1052:9: localconstantdeclaration sEMICOLON
					{
						pushFollow(FOLLOW_localconstantdeclaration_in_declarationstatement6478);
						localconstantdeclaration453 =
							localconstantdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_localconstantdeclaration
								.add(localconstantdeclaration453.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_declarationstatement6480);
						sEMICOLON454 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON454.getTree());

						// AST REWRITE
						// elements: localconstantdeclaration, sEMICOLON
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1053:5: -> ^( DeclarationStatement localconstantdeclaration sEMICOLON )
							{
								// ../rsc/CSharp.g3:1053:8: ^( DeclarationStatement localconstantdeclaration sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												DeclarationStatement,
												"DeclarationStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_localconstantdeclaration
											.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "declarationstatement"

	public static class localvariabledeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "localvariabledeclaration"
	// ../rsc/CSharp.g3:1056:1: localvariabledeclaration : type localvariabledeclarators -> ^( LocalVariableDeclaration type localvariabledeclarators ) ;
	public final CSharpParser.localvariabledeclaration_return localvariabledeclaration()
			throws RecognitionException {
		CSharpParser.localvariabledeclaration_return retval =
			new CSharpParser.localvariabledeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.type_return type455 = null;

		CSharpParser.localvariabledeclarators_return localvariabledeclarators456 =
			null;

		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_localvariabledeclarators =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule localvariabledeclarators");
		try {
			// ../rsc/CSharp.g3:1057:5: ( type localvariabledeclarators -> ^( LocalVariableDeclaration type localvariabledeclarators ) )
			// ../rsc/CSharp.g3:1057:9: type localvariabledeclarators
			{
				pushFollow(FOLLOW_type_in_localvariabledeclaration6513);
				type455 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type455.getTree());
				pushFollow(FOLLOW_localvariabledeclarators_in_localvariabledeclaration6515);
				localvariabledeclarators456 = localvariabledeclarators();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_localvariabledeclarators
						.add(localvariabledeclarators456.getTree());

				// AST REWRITE
				// elements: localvariabledeclarators, type
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1058:5: -> ^( LocalVariableDeclaration type localvariabledeclarators )
					{
						// ../rsc/CSharp.g3:1058:8: ^( LocalVariableDeclaration type localvariabledeclarators )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										LocalVariableDeclaration,
										"LocalVariableDeclaration"), root_1);

							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_localvariabledeclarators.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "localvariabledeclaration"

	public static class localvariabledeclarators_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "localvariabledeclarators"
	// ../rsc/CSharp.g3:1061:1: localvariabledeclarators : localvariabledeclarator ( cOMMA localvariabledeclarator )* ;
	public final CSharpParser.localvariabledeclarators_return localvariabledeclarators()
			throws RecognitionException {
		CSharpParser.localvariabledeclarators_return retval =
			new CSharpParser.localvariabledeclarators_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.localvariabledeclarator_return localvariabledeclarator457 =
			null;

		CSharpParser.cOMMA_return cOMMA458 = null;

		CSharpParser.localvariabledeclarator_return localvariabledeclarator459 =
			null;

		try {
			// ../rsc/CSharp.g3:1062:5: ( localvariabledeclarator ( cOMMA localvariabledeclarator )* )
			// ../rsc/CSharp.g3:1062:9: localvariabledeclarator ( cOMMA localvariabledeclarator )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_localvariabledeclarator_in_localvariabledeclarators6549);
				localvariabledeclarator457 = localvariabledeclarator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(
						root_0,
						localvariabledeclarator457.getTree());
				// ../rsc/CSharp.g3:1062:33: ( cOMMA localvariabledeclarator )*
				loop88: do {
					int alt88 = 2;
					int LA88_0 = this.input.LA(1);

					if ((LA88_0 == COMMA)) {
						alt88 = 1;
					}

					switch (alt88) {
						case 1 :
						// ../rsc/CSharp.g3:1062:34: cOMMA localvariabledeclarator
							{
								pushFollow(FOLLOW_cOMMA_in_localvariabledeclarators6552);
								cOMMA458 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor
										.addChild(root_0, cOMMA458.getTree());
								pushFollow(FOLLOW_localvariabledeclarator_in_localvariabledeclarators6554);
								localvariabledeclarator459 =
									localvariabledeclarator();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										localvariabledeclarator459.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "localvariabledeclarators"

	public static class localvariabledeclarator_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "localvariabledeclarator"
	// ../rsc/CSharp.g3:1065:1: localvariabledeclarator : identifier ( aSSIGN localvariableinitializer )? ;
	public final CSharpParser.localvariabledeclarator_return localvariabledeclarator()
			throws RecognitionException {
		CSharpParser.localvariabledeclarator_return retval =
			new CSharpParser.localvariabledeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier460 = null;

		CSharpParser.aSSIGN_return aSSIGN461 = null;

		CSharpParser.localvariableinitializer_return localvariableinitializer462 =
			null;

		try {
			// ../rsc/CSharp.g3:1066:5: ( identifier ( aSSIGN localvariableinitializer )? )
			// ../rsc/CSharp.g3:1066:9: identifier ( aSSIGN localvariableinitializer )?
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_identifier_in_localvariabledeclarator6575);
				identifier460 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, identifier460.getTree());
				// ../rsc/CSharp.g3:1066:20: ( aSSIGN localvariableinitializer )?
				int alt89 = 2;
				int LA89_0 = this.input.LA(1);

				if ((LA89_0 == ASSIGN)) {
					alt89 = 1;
				}
				switch (alt89) {
					case 1 :
					// ../rsc/CSharp.g3:1066:21: aSSIGN localvariableinitializer
						{
							pushFollow(FOLLOW_aSSIGN_in_localvariabledeclarator6578);
							aSSIGN461 = aSSIGN();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								this.adaptor.addChild(root_0, aSSIGN461.getTree());
							pushFollow(FOLLOW_localvariableinitializer_in_localvariabledeclarator6580);
							localvariableinitializer462 =
								localvariableinitializer();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								this.adaptor.addChild(
									root_0,
									localvariableinitializer462.getTree());

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "localvariabledeclarator"

	public static class localvariableinitializer_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "localvariableinitializer"
	// ../rsc/CSharp.g3:1070:1: localvariableinitializer : ( expression | arrayinitializer );
	public final CSharpParser.localvariableinitializer_return localvariableinitializer()
			throws RecognitionException {
		CSharpParser.localvariableinitializer_return retval =
			new CSharpParser.localvariableinitializer_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.expression_return expression463 = null;

		CSharpParser.arrayinitializer_return arrayinitializer464 = null;

		try {
			// ../rsc/CSharp.g3:1071:5: ( expression | arrayinitializer )
			int alt90 = 2;
			int LA90_0 = this.input.LA(1);

			if ((LA90_0 == LPAREN || (LA90_0 >= PLUS && LA90_0 <= MINUS)
					|| (LA90_0 >= EXCLAM && LA90_0 <= TILDE)
					|| (LA90_0 >= INCREMENT && LA90_0 <= DECREMENT)
					|| (LA90_0 >= BASE && LA90_0 <= BOOL) || LA90_0 == BYTE
					|| (LA90_0 >= CHAR && LA90_0 <= CHECKED)
					|| (LA90_0 >= DECIMAL && LA90_0 <= DELEGATE)
					|| LA90_0 == DOUBLE || LA90_0 == FALSE || LA90_0 == FLOAT
					|| LA90_0 == INT || LA90_0 == LONG
					|| (LA90_0 >= NEW && LA90_0 <= OBJECT) || LA90_0 == SBYTE
					|| LA90_0 == SHORT || LA90_0 == STRING || LA90_0 == THIS
					|| LA90_0 == TRUE
					|| (LA90_0 >= TYPEOF && LA90_0 <= UNCHECKED)
					|| LA90_0 == USHORT || (LA90_0 >= ADD && LA90_0 <= Stringliteral))) {
				alt90 = 1;
			}
			else if ((LA90_0 == LBRACE)) {
				alt90 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 90, 0, this.input);

				throw nvae;
			}
			switch (alt90) {
				case 1 :
				// ../rsc/CSharp.g3:1071:9: expression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_expression_in_localvariableinitializer6602);
						expression463 = expression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, expression463.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1072:9: arrayinitializer
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_arrayinitializer_in_localvariableinitializer6612);
						arrayinitializer464 = arrayinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								arrayinitializer464.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "localvariableinitializer"

	public static class localconstantdeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "localconstantdeclaration"
	// ../rsc/CSharp.g3:1075:1: localconstantdeclaration : cONST type constantdeclarators -> ^( LocalConstantDeclaration cONST type constantdeclarators ) ;
	public final CSharpParser.localconstantdeclaration_return localconstantdeclaration()
			throws RecognitionException {
		CSharpParser.localconstantdeclaration_return retval =
			new CSharpParser.localconstantdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cONST_return cONST465 = null;

		CSharpParser.type_return type466 = null;

		CSharpParser.constantdeclarators_return constantdeclarators467 = null;

		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_constantdeclarators =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantdeclarators");
		RewriteRuleSubtreeStream stream_cONST =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cONST");
		try {
			// ../rsc/CSharp.g3:1076:5: ( cONST type constantdeclarators -> ^( LocalConstantDeclaration cONST type constantdeclarators ) )
			// ../rsc/CSharp.g3:1076:9: cONST type constantdeclarators
			{
				pushFollow(FOLLOW_cONST_in_localconstantdeclaration6631);
				cONST465 = cONST();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cONST.add(cONST465.getTree());
				pushFollow(FOLLOW_type_in_localconstantdeclaration6633);
				type466 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type466.getTree());
				pushFollow(FOLLOW_constantdeclarators_in_localconstantdeclaration6635);
				constantdeclarators467 = constantdeclarators();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_constantdeclarators.add(constantdeclarators467
						.getTree());

				// AST REWRITE
				// elements: cONST, constantdeclarators, type
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1077:5: -> ^( LocalConstantDeclaration cONST type constantdeclarators )
					{
						// ../rsc/CSharp.g3:1077:8: ^( LocalConstantDeclaration cONST type constantdeclarators )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										LocalConstantDeclaration,
										"LocalConstantDeclaration"), root_1);

							this.adaptor.addChild(root_1, stream_cONST.nextTree());
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_constantdeclarators.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "localconstantdeclaration"

	public static class expressionstatement_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "expressionstatement"
	// ../rsc/CSharp.g3:1081:1: expressionstatement : statementexpression sEMICOLON -> ^( ExpressionStatement statementexpression sEMICOLON ) ;
	public final CSharpParser.expressionstatement_return expressionstatement()
			throws RecognitionException {
		CSharpParser.expressionstatement_return retval =
			new CSharpParser.expressionstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.statementexpression_return statementexpression468 = null;

		CSharpParser.sEMICOLON_return sEMICOLON469 = null;

		RewriteRuleSubtreeStream stream_statementexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule statementexpression");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1082:5: ( statementexpression sEMICOLON -> ^( ExpressionStatement statementexpression sEMICOLON ) )
			// ../rsc/CSharp.g3:1082:9: statementexpression sEMICOLON
			{
				pushFollow(FOLLOW_statementexpression_in_expressionstatement6671);
				statementexpression468 = statementexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_statementexpression.add(statementexpression468
						.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_expressionstatement6673);
				sEMICOLON469 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON469.getTree());

				// AST REWRITE
				// elements: sEMICOLON, statementexpression
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1083:5: -> ^( ExpressionStatement statementexpression sEMICOLON )
					{
						// ../rsc/CSharp.g3:1083:8: ^( ExpressionStatement statementexpression sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ExpressionStatement,
										"ExpressionStatement"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_statementexpression.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "expressionstatement"

	public static class statementexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "statementexpression"
	// ../rsc/CSharp.g3:1086:1: statementexpression : ( invocationexpression | objectcreationexpression | assignment | postincrementexpression | postdecrementexpression | preincrementexpression | predecrementexpression );
	public final CSharpParser.statementexpression_return statementexpression()
			throws RecognitionException {
		CSharpParser.statementexpression_return retval =
			new CSharpParser.statementexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.invocationexpression_return invocationexpression470 = null;

		CSharpParser.objectcreationexpression_return objectcreationexpression471 =
			null;

		CSharpParser.assignment_return assignment472 = null;

		CSharpParser.postincrementexpression_return postincrementexpression473 =
			null;

		CSharpParser.postdecrementexpression_return postdecrementexpression474 =
			null;

		CSharpParser.preincrementexpression_return preincrementexpression475 =
			null;

		CSharpParser.predecrementexpression_return predecrementexpression476 =
			null;

		try {
			// ../rsc/CSharp.g3:1087:5: ( invocationexpression | objectcreationexpression | assignment | postincrementexpression | postdecrementexpression | preincrementexpression | predecrementexpression )
			int alt91 = 7;
			alt91 = this.dfa91.predict(this.input);
			switch (alt91) {
				case 1 :
				// ../rsc/CSharp.g3:1087:8: invocationexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_invocationexpression_in_statementexpression6705);
						invocationexpression470 = invocationexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								invocationexpression470.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1089:6: objectcreationexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_objectcreationexpression_in_statementexpression6727);
						objectcreationexpression471 =
							objectcreationexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								objectcreationexpression471.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1090:9: assignment
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_assignment_in_statementexpression6737);
						assignment472 = assignment();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, assignment472.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1091:9: postincrementexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_postincrementexpression_in_statementexpression6747);
						postincrementexpression473 = postincrementexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								postincrementexpression473.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1092:9: postdecrementexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_postdecrementexpression_in_statementexpression6757);
						postdecrementexpression474 = postdecrementexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								postdecrementexpression474.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:1093:9: preincrementexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_preincrementexpression_in_statementexpression6767);
						preincrementexpression475 = preincrementexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								preincrementexpression475.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:1094:9: predecrementexpression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_predecrementexpression_in_statementexpression6777);
						predecrementexpression476 = predecrementexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								predecrementexpression476.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "statementexpression"

	public static class selectionstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "selectionstatement"
	// ../rsc/CSharp.g3:1097:1: selectionstatement : ( ifstatement | switchstatement );
	public final CSharpParser.selectionstatement_return selectionstatement()
			throws RecognitionException {
		CSharpParser.selectionstatement_return retval =
			new CSharpParser.selectionstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.ifstatement_return ifstatement477 = null;

		CSharpParser.switchstatement_return switchstatement478 = null;

		try {
			// ../rsc/CSharp.g3:1098:5: ( ifstatement | switchstatement )
			int alt92 = 2;
			int LA92_0 = this.input.LA(1);

			if ((LA92_0 == IF)) {
				alt92 = 1;
			}
			else if ((LA92_0 == SWITCH)) {
				alt92 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 92, 0, this.input);

				throw nvae;
			}
			switch (alt92) {
				case 1 :
				// ../rsc/CSharp.g3:1098:9: ifstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_ifstatement_in_selectionstatement6796);
						ifstatement477 = ifstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, ifstatement477.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1099:9: switchstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_switchstatement_in_selectionstatement6806);
						switchstatement478 = switchstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								switchstatement478.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "selectionstatement"

	public static class ifstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "ifstatement"
	// ../rsc/CSharp.g3:1102:1: ifstatement : ( iF lPAREN booleanexpression rPAREN embeddedstatement eLSE embeddedstatement -> ^( IfStatement iF lPAREN booleanexpression rPAREN ^( IfSection embeddedstatement ) eLSE ^( ElseSection embeddedstatement ) ) | iF lPAREN booleanexpression rPAREN embeddedstatement -> ^( IfStatement iF lPAREN booleanexpression rPAREN ^( IfSection embeddedstatement ) ) );
	public final CSharpParser.ifstatement_return ifstatement()
			throws RecognitionException {
		CSharpParser.ifstatement_return retval =
			new CSharpParser.ifstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.iF_return iF479 = null;

		CSharpParser.lPAREN_return lPAREN480 = null;

		CSharpParser.booleanexpression_return booleanexpression481 = null;

		CSharpParser.rPAREN_return rPAREN482 = null;

		CSharpParser.embeddedstatement_return embeddedstatement483 = null;

		CSharpParser.eLSE_return eLSE484 = null;

		CSharpParser.embeddedstatement_return embeddedstatement485 = null;

		CSharpParser.iF_return iF486 = null;

		CSharpParser.lPAREN_return lPAREN487 = null;

		CSharpParser.booleanexpression_return booleanexpression488 = null;

		CSharpParser.rPAREN_return rPAREN489 = null;

		CSharpParser.embeddedstatement_return embeddedstatement490 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_eLSE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eLSE");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_booleanexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule booleanexpression");
		RewriteRuleSubtreeStream stream_embeddedstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule embeddedstatement");
		RewriteRuleSubtreeStream stream_iF =
			new RewriteRuleSubtreeStream(this.adaptor, "rule iF");
		try {
			// ../rsc/CSharp.g3:1103:5: ( iF lPAREN booleanexpression rPAREN embeddedstatement eLSE embeddedstatement -> ^( IfStatement iF lPAREN booleanexpression rPAREN ^( IfSection embeddedstatement ) eLSE ^( ElseSection embeddedstatement ) ) | iF lPAREN booleanexpression rPAREN embeddedstatement -> ^( IfStatement iF lPAREN booleanexpression rPAREN ^( IfSection embeddedstatement ) ) )
			int alt93 = 2;
			int LA93_0 = this.input.LA(1);

			if ((LA93_0 == IF)) {
				this.input.LA(2);

				if ((synpred275_CSharp())) {
					alt93 = 1;
				}
				else if ((true)) {
					alt93 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 93, 0, this.input);

				throw nvae;
			}
			switch (alt93) {
				case 1 :
				// ../rsc/CSharp.g3:1103:9: iF lPAREN booleanexpression rPAREN embeddedstatement eLSE embeddedstatement
					{
						pushFollow(FOLLOW_iF_in_ifstatement6825);
						iF479 = iF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_iF.add(iF479.getTree());
						pushFollow(FOLLOW_lPAREN_in_ifstatement6827);
						lPAREN480 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN480.getTree());
						pushFollow(FOLLOW_booleanexpression_in_ifstatement6829);
						booleanexpression481 = booleanexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_booleanexpression.add(booleanexpression481
								.getTree());
						pushFollow(FOLLOW_rPAREN_in_ifstatement6831);
						rPAREN482 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN482.getTree());
						pushFollow(FOLLOW_embeddedstatement_in_ifstatement6833);
						embeddedstatement483 = embeddedstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_embeddedstatement.add(embeddedstatement483
								.getTree());
						pushFollow(FOLLOW_eLSE_in_ifstatement6835);
						eLSE484 = eLSE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_eLSE.add(eLSE484.getTree());
						pushFollow(FOLLOW_embeddedstatement_in_ifstatement6837);
						embeddedstatement485 = embeddedstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_embeddedstatement.add(embeddedstatement485
								.getTree());

						// AST REWRITE
						// elements: embeddedstatement, iF, lPAREN, rPAREN, embeddedstatement, eLSE, booleanexpression
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1104:5: -> ^( IfStatement iF lPAREN booleanexpression rPAREN ^( IfSection embeddedstatement ) eLSE ^( ElseSection embeddedstatement ) )
							{
								// ../rsc/CSharp.g3:1104:8: ^( IfStatement iF lPAREN booleanexpression rPAREN ^( IfSection embeddedstatement ) eLSE ^( ElseSection embeddedstatement ) )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												IfStatement,
												"IfStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_iF.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_booleanexpression.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());
									// ../rsc/CSharp.g3:1104:57: ^( IfSection embeddedstatement )
									{
										Object root_2 = (Object) this.adaptor.nil();
										root_2 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													IfSection,
													"IfSection"),
												root_2);

										this.adaptor
											.addChild(
												root_2,
												stream_embeddedstatement
													.nextTree());

										this.adaptor.addChild(root_1, root_2);
									}
									this.adaptor.addChild(
										root_1,
										stream_eLSE.nextTree());
									// ../rsc/CSharp.g3:1104:93: ^( ElseSection embeddedstatement )
									{
										Object root_2 = (Object) this.adaptor.nil();
										root_2 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													ElseSection,
													"ElseSection"),
												root_2);

										this.adaptor
											.addChild(
												root_2,
												stream_embeddedstatement
													.nextTree());

										this.adaptor.addChild(root_1, root_2);
									}

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1105:9: iF lPAREN booleanexpression rPAREN embeddedstatement
					{
						pushFollow(FOLLOW_iF_in_ifstatement6879);
						iF486 = iF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_iF.add(iF486.getTree());
						pushFollow(FOLLOW_lPAREN_in_ifstatement6881);
						lPAREN487 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN487.getTree());
						pushFollow(FOLLOW_booleanexpression_in_ifstatement6883);
						booleanexpression488 = booleanexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_booleanexpression.add(booleanexpression488
								.getTree());
						pushFollow(FOLLOW_rPAREN_in_ifstatement6885);
						rPAREN489 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN489.getTree());
						pushFollow(FOLLOW_embeddedstatement_in_ifstatement6887);
						embeddedstatement490 = embeddedstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_embeddedstatement.add(embeddedstatement490
								.getTree());

						// AST REWRITE
						// elements: rPAREN, booleanexpression, embeddedstatement, iF, lPAREN
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1106:5: -> ^( IfStatement iF lPAREN booleanexpression rPAREN ^( IfSection embeddedstatement ) )
							{
								// ../rsc/CSharp.g3:1106:8: ^( IfStatement iF lPAREN booleanexpression rPAREN ^( IfSection embeddedstatement ) )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												IfStatement,
												"IfStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_iF.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_booleanexpression.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());
									// ../rsc/CSharp.g3:1106:57: ^( IfSection embeddedstatement )
									{
										Object root_2 = (Object) this.adaptor.nil();
										root_2 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													IfSection,
													"IfSection"),
												root_2);

										this.adaptor
											.addChild(
												root_2,
												stream_embeddedstatement
													.nextTree());

										this.adaptor.addChild(root_1, root_2);
									}

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "ifstatement"

	public static class switchstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "switchstatement"
	// ../rsc/CSharp.g3:1109:1: switchstatement : sWITCH lPAREN expression rPAREN switchblock -> ^( SwitchStatement sWITCH lPAREN expression rPAREN switchblock ) ;
	public final CSharpParser.switchstatement_return switchstatement()
			throws RecognitionException {
		CSharpParser.switchstatement_return retval =
			new CSharpParser.switchstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.sWITCH_return sWITCH491 = null;

		CSharpParser.lPAREN_return lPAREN492 = null;

		CSharpParser.expression_return expression493 = null;

		CSharpParser.rPAREN_return rPAREN494 = null;

		CSharpParser.switchblock_return switchblock495 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_switchblock =
			new RewriteRuleSubtreeStream(this.adaptor, "rule switchblock");
		RewriteRuleSubtreeStream stream_sWITCH =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sWITCH");
		try {
			// ../rsc/CSharp.g3:1110:5: ( sWITCH lPAREN expression rPAREN switchblock -> ^( SwitchStatement sWITCH lPAREN expression rPAREN switchblock ) )
			// ../rsc/CSharp.g3:1110:9: sWITCH lPAREN expression rPAREN switchblock
			{
				pushFollow(FOLLOW_sWITCH_in_switchstatement6930);
				sWITCH491 = sWITCH();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sWITCH.add(sWITCH491.getTree());
				pushFollow(FOLLOW_lPAREN_in_switchstatement6932);
				lPAREN492 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN492.getTree());
				pushFollow(FOLLOW_expression_in_switchstatement6934);
				expression493 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression493.getTree());
				pushFollow(FOLLOW_rPAREN_in_switchstatement6936);
				rPAREN494 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN494.getTree());
				pushFollow(FOLLOW_switchblock_in_switchstatement6938);
				switchblock495 = switchblock();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_switchblock.add(switchblock495.getTree());

				// AST REWRITE
				// elements: rPAREN, switchblock, expression, lPAREN, sWITCH
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1111:5: -> ^( SwitchStatement sWITCH lPAREN expression rPAREN switchblock )
					{
						// ../rsc/CSharp.g3:1111:8: ^( SwitchStatement sWITCH lPAREN expression rPAREN switchblock )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										SwitchStatement,
										"SwitchStatement"),
									root_1);

							this.adaptor.addChild(root_1, stream_sWITCH.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_switchblock.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "switchstatement"

	public static class switchblock_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "switchblock"
	// ../rsc/CSharp.g3:1114:1: switchblock : lBRACE ( switchsections )? rBRACE -> ^( Block lBRACE ( switchsections )? rBRACE ) ;
	public final CSharpParser.switchblock_return switchblock()
			throws RecognitionException {
		CSharpParser.switchblock_return retval =
			new CSharpParser.switchblock_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACE_return lBRACE496 = null;

		CSharpParser.switchsections_return switchsections497 = null;

		CSharpParser.rBRACE_return rBRACE498 = null;

		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_switchsections =
			new RewriteRuleSubtreeStream(this.adaptor, "rule switchsections");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:1115:5: ( lBRACE ( switchsections )? rBRACE -> ^( Block lBRACE ( switchsections )? rBRACE ) )
			// ../rsc/CSharp.g3:1115:9: lBRACE ( switchsections )? rBRACE
			{
				pushFollow(FOLLOW_lBRACE_in_switchblock6977);
				lBRACE496 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE496.getTree());
				// ../rsc/CSharp.g3:1115:16: ( switchsections )?
				int alt94 = 2;
				int LA94_0 = this.input.LA(1);

				if ((LA94_0 == CASE || LA94_0 == DEFAULT)) {
					alt94 = 1;
				}
				switch (alt94) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: switchsections
						{
							pushFollow(FOLLOW_switchsections_in_switchblock6979);
							switchsections497 = switchsections();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_switchsections.add(switchsections497
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rBRACE_in_switchblock6982);
				rBRACE498 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE498.getTree());

				// AST REWRITE
				// elements: switchsections, rBRACE, lBRACE
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1116:5: -> ^( Block lBRACE ( switchsections )? rBRACE )
					{
						// ../rsc/CSharp.g3:1116:8: ^( Block lBRACE ( switchsections )? rBRACE )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Block, "Block"),
									root_1);

							this.adaptor.addChild(root_1, stream_lBRACE.nextTree());
							// ../rsc/CSharp.g3:1116:23: ( switchsections )?
							if (stream_switchsections.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_switchsections.nextTree());

							}
							stream_switchsections.reset();
							this.adaptor.addChild(root_1, stream_rBRACE.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "switchblock"

	public static class switchsections_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "switchsections"
	// ../rsc/CSharp.g3:1119:1: switchsections : ( switchsection )+ ;
	public final CSharpParser.switchsections_return switchsections()
			throws RecognitionException {
		CSharpParser.switchsections_return retval =
			new CSharpParser.switchsections_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.switchsection_return switchsection499 = null;

		try {
			// ../rsc/CSharp.g3:1120:5: ( ( switchsection )+ )
			// ../rsc/CSharp.g3:1120:9: ( switchsection )+
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:1120:9: ( switchsection )+
				int cnt95 = 0;
				loop95: do {
					int alt95 = 2;
					int LA95_0 = this.input.LA(1);

					if ((LA95_0 == CASE || LA95_0 == DEFAULT)) {
						alt95 = 1;
					}

					switch (alt95) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: switchsection
							{
								pushFollow(FOLLOW_switchsection_in_switchsections7019);
								switchsection499 = switchsection();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										switchsection499.getTree());

							}
							break;

						default :
							if (cnt95 >= 1)
								break loop95;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(95, this.input);
							throw eee;
					}
					cnt95++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "switchsections"

	public static class switchsection_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "switchsection"
	// ../rsc/CSharp.g3:1123:1: switchsection : switchlabels statementlist -> ^( SwitchSection switchlabels statementlist ) ;
	public final CSharpParser.switchsection_return switchsection()
			throws RecognitionException {
		CSharpParser.switchsection_return retval =
			new CSharpParser.switchsection_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.switchlabels_return switchlabels500 = null;

		CSharpParser.statementlist_return statementlist501 = null;

		RewriteRuleSubtreeStream stream_switchlabels =
			new RewriteRuleSubtreeStream(this.adaptor, "rule switchlabels");
		RewriteRuleSubtreeStream stream_statementlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule statementlist");
		try {
			// ../rsc/CSharp.g3:1124:5: ( switchlabels statementlist -> ^( SwitchSection switchlabels statementlist ) )
			// ../rsc/CSharp.g3:1124:9: switchlabels statementlist
			{
				pushFollow(FOLLOW_switchlabels_in_switchsection7039);
				switchlabels500 = switchlabels();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_switchlabels.add(switchlabels500.getTree());
				pushFollow(FOLLOW_statementlist_in_switchsection7041);
				statementlist501 = statementlist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_statementlist.add(statementlist501.getTree());

				// AST REWRITE
				// elements: statementlist, switchlabels
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1125:5: -> ^( SwitchSection switchlabels statementlist )
					{
						// ../rsc/CSharp.g3:1125:8: ^( SwitchSection switchlabels statementlist )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										SwitchSection,
										"SwitchSection"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_switchlabels.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_statementlist.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "switchsection"

	public static class switchlabels_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "switchlabels"
	// ../rsc/CSharp.g3:1128:1: switchlabels : ( switchlabel )+ ;
	public final CSharpParser.switchlabels_return switchlabels()
			throws RecognitionException {
		CSharpParser.switchlabels_return retval =
			new CSharpParser.switchlabels_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.switchlabel_return switchlabel502 = null;

		try {
			// ../rsc/CSharp.g3:1129:5: ( ( switchlabel )+ )
			// ../rsc/CSharp.g3:1129:9: ( switchlabel )+
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:1129:9: ( switchlabel )+
				int cnt96 = 0;
				loop96: do {
					int alt96 = 2;
					alt96 = this.dfa96.predict(this.input);
					switch (alt96) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: switchlabel
							{
								pushFollow(FOLLOW_switchlabel_in_switchlabels7075);
								switchlabel502 = switchlabel();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										switchlabel502.getTree());

							}
							break;

						default :
							if (cnt96 >= 1)
								break loop96;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(96, this.input);
							throw eee;
					}
					cnt96++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "switchlabels"

	public static class switchlabel_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "switchlabel"
	// ../rsc/CSharp.g3:1132:1: switchlabel : ( cASE constantexpression cOLON -> ^( SwitchLabel cASE constantexpression cOLON ) | dEFAULT cOLON -> ^( SwitchLabel dEFAULT cOLON ) );
	public final CSharpParser.switchlabel_return switchlabel()
			throws RecognitionException {
		CSharpParser.switchlabel_return retval =
			new CSharpParser.switchlabel_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cASE_return cASE503 = null;

		CSharpParser.constantexpression_return constantexpression504 = null;

		CSharpParser.cOLON_return cOLON505 = null;

		CSharpParser.dEFAULT_return dEFAULT506 = null;

		CSharpParser.cOLON_return cOLON507 = null;

		RewriteRuleSubtreeStream stream_cOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOLON");
		RewriteRuleSubtreeStream stream_dEFAULT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dEFAULT");
		RewriteRuleSubtreeStream stream_constantexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantexpression");
		RewriteRuleSubtreeStream stream_cASE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cASE");
		try {
			// ../rsc/CSharp.g3:1133:5: ( cASE constantexpression cOLON -> ^( SwitchLabel cASE constantexpression cOLON ) | dEFAULT cOLON -> ^( SwitchLabel dEFAULT cOLON ) )
			int alt97 = 2;
			int LA97_0 = this.input.LA(1);

			if ((LA97_0 == CASE)) {
				alt97 = 1;
			}
			else if ((LA97_0 == DEFAULT)) {
				alt97 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 97, 0, this.input);

				throw nvae;
			}
			switch (alt97) {
				case 1 :
				// ../rsc/CSharp.g3:1133:9: cASE constantexpression cOLON
					{
						pushFollow(FOLLOW_cASE_in_switchlabel7095);
						cASE503 = cASE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cASE.add(cASE503.getTree());
						pushFollow(FOLLOW_constantexpression_in_switchlabel7097);
						constantexpression504 = constantexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constantexpression.add(constantexpression504
								.getTree());
						pushFollow(FOLLOW_cOLON_in_switchlabel7099);
						cOLON505 = cOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOLON.add(cOLON505.getTree());

						// AST REWRITE
						// elements: constantexpression, cOLON, cASE
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1134:5: -> ^( SwitchLabel cASE constantexpression cOLON )
							{
								// ../rsc/CSharp.g3:1134:8: ^( SwitchLabel cASE constantexpression cOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												SwitchLabel,
												"SwitchLabel"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_cASE.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_constantexpression.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1135:9: dEFAULT cOLON
					{
						pushFollow(FOLLOW_dEFAULT_in_switchlabel7125);
						dEFAULT506 = dEFAULT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_dEFAULT.add(dEFAULT506.getTree());
						pushFollow(FOLLOW_cOLON_in_switchlabel7127);
						cOLON507 = cOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOLON.add(cOLON507.getTree());

						// AST REWRITE
						// elements: dEFAULT, cOLON
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1136:5: -> ^( SwitchLabel dEFAULT cOLON )
							{
								// ../rsc/CSharp.g3:1136:8: ^( SwitchLabel dEFAULT cOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												SwitchLabel,
												"SwitchLabel"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_dEFAULT.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "switchlabel"

	public static class iterationstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iterationstatement"
	// ../rsc/CSharp.g3:1139:1: iterationstatement : ( whilestatement | dostatement | forstatement | foreachstatement );
	public final CSharpParser.iterationstatement_return iterationstatement()
			throws RecognitionException {
		CSharpParser.iterationstatement_return retval =
			new CSharpParser.iterationstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.whilestatement_return whilestatement508 = null;

		CSharpParser.dostatement_return dostatement509 = null;

		CSharpParser.forstatement_return forstatement510 = null;

		CSharpParser.foreachstatement_return foreachstatement511 = null;

		try {
			// ../rsc/CSharp.g3:1140:5: ( whilestatement | dostatement | forstatement | foreachstatement )
			int alt98 = 4;
			switch (this.input.LA(1)) {
				case WHILE :
					{
						alt98 = 1;
					}
					break;
				case DO :
					{
						alt98 = 2;
					}
					break;
				case FOR :
					{
						alt98 = 3;
					}
					break;
				case FOREACH :
					{
						alt98 = 4;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 98, 0, this.input);

					throw nvae;
			}

			switch (alt98) {
				case 1 :
				// ../rsc/CSharp.g3:1140:9: whilestatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_whilestatement_in_iterationstatement7160);
						whilestatement508 = whilestatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								whilestatement508.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1141:9: dostatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dostatement_in_iterationstatement7170);
						dostatement509 = dostatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dostatement509.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1142:9: forstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_forstatement_in_iterationstatement7180);
						forstatement510 = forstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, forstatement510.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1143:9: foreachstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_foreachstatement_in_iterationstatement7190);
						foreachstatement511 = foreachstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								foreachstatement511.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iterationstatement"

	public static class whilestatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "whilestatement"
	// ../rsc/CSharp.g3:1146:1: whilestatement : wHILE lPAREN booleanexpression rPAREN embeddedstatement -> ^( WhileStatement wHILE lPAREN booleanexpression rPAREN embeddedstatement ) ;
	public final CSharpParser.whilestatement_return whilestatement()
			throws RecognitionException {
		CSharpParser.whilestatement_return retval =
			new CSharpParser.whilestatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.wHILE_return wHILE512 = null;

		CSharpParser.lPAREN_return lPAREN513 = null;

		CSharpParser.booleanexpression_return booleanexpression514 = null;

		CSharpParser.rPAREN_return rPAREN515 = null;

		CSharpParser.embeddedstatement_return embeddedstatement516 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_booleanexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule booleanexpression");
		RewriteRuleSubtreeStream stream_embeddedstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule embeddedstatement");
		RewriteRuleSubtreeStream stream_wHILE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule wHILE");
		try {
			// ../rsc/CSharp.g3:1147:5: ( wHILE lPAREN booleanexpression rPAREN embeddedstatement -> ^( WhileStatement wHILE lPAREN booleanexpression rPAREN embeddedstatement ) )
			// ../rsc/CSharp.g3:1147:9: wHILE lPAREN booleanexpression rPAREN embeddedstatement
			{
				pushFollow(FOLLOW_wHILE_in_whilestatement7209);
				wHILE512 = wHILE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_wHILE.add(wHILE512.getTree());
				pushFollow(FOLLOW_lPAREN_in_whilestatement7211);
				lPAREN513 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN513.getTree());
				pushFollow(FOLLOW_booleanexpression_in_whilestatement7213);
				booleanexpression514 = booleanexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_booleanexpression
						.add(booleanexpression514.getTree());
				pushFollow(FOLLOW_rPAREN_in_whilestatement7215);
				rPAREN515 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN515.getTree());
				pushFollow(FOLLOW_embeddedstatement_in_whilestatement7217);
				embeddedstatement516 = embeddedstatement();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_embeddedstatement
						.add(embeddedstatement516.getTree());

				// AST REWRITE
				// elements: booleanexpression, embeddedstatement, wHILE, rPAREN, lPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1148:5: -> ^( WhileStatement wHILE lPAREN booleanexpression rPAREN embeddedstatement )
					{
						// ../rsc/CSharp.g3:1148:8: ^( WhileStatement wHILE lPAREN booleanexpression rPAREN embeddedstatement )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										WhileStatement,
										"WhileStatement"),
									root_1);

							this.adaptor.addChild(root_1, stream_wHILE.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_booleanexpression.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_embeddedstatement.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "whilestatement"

	public static class dostatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dostatement"
	// ../rsc/CSharp.g3:1153:1: dostatement : dO embeddedstatement wHILE lPAREN booleanexpression rPAREN sEMICOLON -> ^( DoStatement dO embeddedstatement wHILE lPAREN booleanexpression rPAREN sEMICOLON ) ;
	public final CSharpParser.dostatement_return dostatement()
			throws RecognitionException {
		CSharpParser.dostatement_return retval =
			new CSharpParser.dostatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.dO_return dO517 = null;

		CSharpParser.embeddedstatement_return embeddedstatement518 = null;

		CSharpParser.wHILE_return wHILE519 = null;

		CSharpParser.lPAREN_return lPAREN520 = null;

		CSharpParser.booleanexpression_return booleanexpression521 = null;

		CSharpParser.rPAREN_return rPAREN522 = null;

		CSharpParser.sEMICOLON_return sEMICOLON523 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_dO =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dO");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_booleanexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule booleanexpression");
		RewriteRuleSubtreeStream stream_embeddedstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule embeddedstatement");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_wHILE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule wHILE");
		try {
			// ../rsc/CSharp.g3:1154:5: ( dO embeddedstatement wHILE lPAREN booleanexpression rPAREN sEMICOLON -> ^( DoStatement dO embeddedstatement wHILE lPAREN booleanexpression rPAREN sEMICOLON ) )
			// ../rsc/CSharp.g3:1154:9: dO embeddedstatement wHILE lPAREN booleanexpression rPAREN sEMICOLON
			{
				pushFollow(FOLLOW_dO_in_dostatement7258);
				dO517 = dO();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_dO.add(dO517.getTree());
				pushFollow(FOLLOW_embeddedstatement_in_dostatement7260);
				embeddedstatement518 = embeddedstatement();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_embeddedstatement
						.add(embeddedstatement518.getTree());
				pushFollow(FOLLOW_wHILE_in_dostatement7262);
				wHILE519 = wHILE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_wHILE.add(wHILE519.getTree());
				pushFollow(FOLLOW_lPAREN_in_dostatement7264);
				lPAREN520 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN520.getTree());
				pushFollow(FOLLOW_booleanexpression_in_dostatement7266);
				booleanexpression521 = booleanexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_booleanexpression
						.add(booleanexpression521.getTree());
				pushFollow(FOLLOW_rPAREN_in_dostatement7268);
				rPAREN522 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN522.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_dostatement7270);
				sEMICOLON523 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON523.getTree());

				// AST REWRITE
				// elements: booleanexpression, embeddedstatement, lPAREN, sEMICOLON, dO, rPAREN, wHILE
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1155:5: -> ^( DoStatement dO embeddedstatement wHILE lPAREN booleanexpression rPAREN sEMICOLON )
					{
						// ../rsc/CSharp.g3:1155:8: ^( DoStatement dO embeddedstatement wHILE lPAREN booleanexpression rPAREN sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										DoStatement,
										"DoStatement"), root_1);

							this.adaptor.addChild(root_1, stream_dO.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_embeddedstatement.nextTree());
							this.adaptor.addChild(root_1, stream_wHILE.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_booleanexpression.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dostatement"

	public static class forstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "forstatement"
	// ../rsc/CSharp.g3:1158:1: forstatement : fOR lPAREN ( forinitializer )? sEMICOLON ( forcondition )? sEMICOLON ( foriterator )? rPAREN embeddedstatement -> ^( ForStatement fOR lPAREN ( forinitializer )? sEMICOLON ( forcondition )? sEMICOLON ( foriterator )? rPAREN embeddedstatement ) ;
	public final CSharpParser.forstatement_return forstatement()
			throws RecognitionException {
		CSharpParser.forstatement_return retval =
			new CSharpParser.forstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.fOR_return fOR524 = null;

		CSharpParser.lPAREN_return lPAREN525 = null;

		CSharpParser.forinitializer_return forinitializer526 = null;

		CSharpParser.sEMICOLON_return sEMICOLON527 = null;

		CSharpParser.forcondition_return forcondition528 = null;

		CSharpParser.sEMICOLON_return sEMICOLON529 = null;

		CSharpParser.foriterator_return foriterator530 = null;

		CSharpParser.rPAREN_return rPAREN531 = null;

		CSharpParser.embeddedstatement_return embeddedstatement532 = null;

		RewriteRuleSubtreeStream stream_forinitializer =
			new RewriteRuleSubtreeStream(this.adaptor, "rule forinitializer");
		RewriteRuleSubtreeStream stream_foriterator =
			new RewriteRuleSubtreeStream(this.adaptor, "rule foriterator");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_forcondition =
			new RewriteRuleSubtreeStream(this.adaptor, "rule forcondition");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_embeddedstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule embeddedstatement");
		RewriteRuleSubtreeStream stream_fOR =
			new RewriteRuleSubtreeStream(this.adaptor, "rule fOR");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1159:5: ( fOR lPAREN ( forinitializer )? sEMICOLON ( forcondition )? sEMICOLON ( foriterator )? rPAREN embeddedstatement -> ^( ForStatement fOR lPAREN ( forinitializer )? sEMICOLON ( forcondition )? sEMICOLON ( foriterator )? rPAREN embeddedstatement ) )
			// ../rsc/CSharp.g3:1159:9: fOR lPAREN ( forinitializer )? sEMICOLON ( forcondition )? sEMICOLON ( foriterator )? rPAREN embeddedstatement
			{
				pushFollow(FOLLOW_fOR_in_forstatement7313);
				fOR524 = fOR();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_fOR.add(fOR524.getTree());
				pushFollow(FOLLOW_lPAREN_in_forstatement7315);
				lPAREN525 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN525.getTree());
				// ../rsc/CSharp.g3:1159:20: ( forinitializer )?
				int alt99 = 2;
				int LA99_0 = this.input.LA(1);

				if ((LA99_0 == LPAREN || (LA99_0 >= PLUS && LA99_0 <= MINUS)
						|| (LA99_0 >= EXCLAM && LA99_0 <= TILDE)
						|| (LA99_0 >= INCREMENT && LA99_0 <= DECREMENT)
						|| (LA99_0 >= BASE && LA99_0 <= BOOL) || LA99_0 == BYTE
						|| (LA99_0 >= CHAR && LA99_0 <= CHECKED)
						|| (LA99_0 >= DECIMAL && LA99_0 <= DELEGATE)
						|| LA99_0 == DOUBLE || LA99_0 == FALSE
						|| LA99_0 == FLOAT || LA99_0 == INT || LA99_0 == LONG
						|| (LA99_0 >= NEW && LA99_0 <= OBJECT)
						|| LA99_0 == SBYTE || LA99_0 == SHORT
						|| LA99_0 == STRING || LA99_0 == THIS || LA99_0 == TRUE
						|| (LA99_0 >= TYPEOF && LA99_0 <= UNCHECKED)
						|| LA99_0 == USHORT || (LA99_0 >= ADD && LA99_0 <= Stringliteral))) {
					alt99 = 1;
				}
				switch (alt99) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: forinitializer
						{
							pushFollow(FOLLOW_forinitializer_in_forstatement7317);
							forinitializer526 = forinitializer();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_forinitializer.add(forinitializer526
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_sEMICOLON_in_forstatement7320);
				sEMICOLON527 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON527.getTree());
				// ../rsc/CSharp.g3:1159:46: ( forcondition )?
				int alt100 = 2;
				int LA100_0 = this.input.LA(1);

				if ((LA100_0 == LPAREN || (LA100_0 >= PLUS && LA100_0 <= MINUS)
						|| (LA100_0 >= EXCLAM && LA100_0 <= TILDE)
						|| (LA100_0 >= INCREMENT && LA100_0 <= DECREMENT)
						|| (LA100_0 >= BASE && LA100_0 <= BOOL)
						|| LA100_0 == BYTE
						|| (LA100_0 >= CHAR && LA100_0 <= CHECKED)
						|| (LA100_0 >= DECIMAL && LA100_0 <= DELEGATE)
						|| LA100_0 == DOUBLE || LA100_0 == FALSE
						|| LA100_0 == FLOAT || LA100_0 == INT
						|| LA100_0 == LONG
						|| (LA100_0 >= NEW && LA100_0 <= OBJECT)
						|| LA100_0 == SBYTE || LA100_0 == SHORT
						|| LA100_0 == STRING || LA100_0 == THIS
						|| LA100_0 == TRUE
						|| (LA100_0 >= TYPEOF && LA100_0 <= UNCHECKED)
						|| LA100_0 == USHORT || (LA100_0 >= ADD && LA100_0 <= Stringliteral))) {
					alt100 = 1;
				}
				switch (alt100) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: forcondition
						{
							pushFollow(FOLLOW_forcondition_in_forstatement7322);
							forcondition528 = forcondition();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_forcondition.add(forcondition528
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_sEMICOLON_in_forstatement7325);
				sEMICOLON529 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON529.getTree());
				// ../rsc/CSharp.g3:1159:70: ( foriterator )?
				int alt101 = 2;
				int LA101_0 = this.input.LA(1);

				if ((LA101_0 == LPAREN || (LA101_0 >= PLUS && LA101_0 <= MINUS)
						|| (LA101_0 >= EXCLAM && LA101_0 <= TILDE)
						|| (LA101_0 >= INCREMENT && LA101_0 <= DECREMENT)
						|| (LA101_0 >= BASE && LA101_0 <= BOOL)
						|| LA101_0 == BYTE
						|| (LA101_0 >= CHAR && LA101_0 <= CHECKED)
						|| (LA101_0 >= DECIMAL && LA101_0 <= DELEGATE)
						|| LA101_0 == DOUBLE || LA101_0 == FALSE
						|| LA101_0 == FLOAT || LA101_0 == INT
						|| LA101_0 == LONG
						|| (LA101_0 >= NEW && LA101_0 <= OBJECT)
						|| LA101_0 == SBYTE || LA101_0 == SHORT
						|| LA101_0 == STRING || LA101_0 == THIS
						|| LA101_0 == TRUE
						|| (LA101_0 >= TYPEOF && LA101_0 <= UNCHECKED)
						|| LA101_0 == USHORT || (LA101_0 >= ADD && LA101_0 <= Stringliteral))) {
					alt101 = 1;
				}
				switch (alt101) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: foriterator
						{
							pushFollow(FOLLOW_foriterator_in_forstatement7327);
							foriterator530 = foriterator();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_foriterator
									.add(foriterator530.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_forstatement7330);
				rPAREN531 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN531.getTree());
				pushFollow(FOLLOW_embeddedstatement_in_forstatement7332);
				embeddedstatement532 = embeddedstatement();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_embeddedstatement
						.add(embeddedstatement532.getTree());

				// AST REWRITE
				// elements: foriterator, forcondition, lPAREN, fOR, embeddedstatement, sEMICOLON, forinitializer, sEMICOLON, rPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1160:5: -> ^( ForStatement fOR lPAREN ( forinitializer )? sEMICOLON ( forcondition )? sEMICOLON ( foriterator )? rPAREN embeddedstatement )
					{
						// ../rsc/CSharp.g3:1160:8: ^( ForStatement fOR lPAREN ( forinitializer )? sEMICOLON ( forcondition )? sEMICOLON ( foriterator )? rPAREN embeddedstatement )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ForStatement,
										"ForStatement"),
									root_1);

							this.adaptor.addChild(root_1, stream_fOR.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							// ../rsc/CSharp.g3:1160:34: ( forinitializer )?
							if (stream_forinitializer.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_forinitializer.nextTree());

							}
							stream_forinitializer.reset();
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());
							// ../rsc/CSharp.g3:1160:60: ( forcondition )?
							if (stream_forcondition.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_forcondition.nextTree());

							}
							stream_forcondition.reset();
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());
							// ../rsc/CSharp.g3:1160:84: ( foriterator )?
							if (stream_foriterator.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_foriterator.nextTree());

							}
							stream_foriterator.reset();
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_embeddedstatement.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "forstatement"

	public static class forinitializer_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "forinitializer"
	// ../rsc/CSharp.g3:1163:1: forinitializer : ( localvariabledeclaration -> ^( ForInitializer localvariabledeclaration ) | statementexpressionlist -> ^( ForInitializer statementexpressionlist ) );
	public final CSharpParser.forinitializer_return forinitializer()
			throws RecognitionException {
		CSharpParser.forinitializer_return retval =
			new CSharpParser.forinitializer_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.localvariabledeclaration_return localvariabledeclaration533 =
			null;

		CSharpParser.statementexpressionlist_return statementexpressionlist534 =
			null;

		RewriteRuleSubtreeStream stream_localvariabledeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule localvariabledeclaration");
		RewriteRuleSubtreeStream stream_statementexpressionlist =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule statementexpressionlist");
		try {
			// ../rsc/CSharp.g3:1164:5: ( localvariabledeclaration -> ^( ForInitializer localvariabledeclaration ) | statementexpressionlist -> ^( ForInitializer statementexpressionlist ) )
			int alt102 = 2;
			alt102 = this.dfa102.predict(this.input);
			switch (alt102) {
				case 1 :
				// ../rsc/CSharp.g3:1164:9: localvariabledeclaration
					{
						pushFollow(FOLLOW_localvariabledeclaration_in_forinitializer7382);
						localvariabledeclaration533 =
							localvariabledeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_localvariabledeclaration
								.add(localvariabledeclaration533.getTree());

						// AST REWRITE
						// elements: localvariabledeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1165:5: -> ^( ForInitializer localvariabledeclaration )
							{
								// ../rsc/CSharp.g3:1165:8: ^( ForInitializer localvariabledeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ForInitializer,
												"ForInitializer"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_localvariabledeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1166:9: statementexpressionlist
					{
						pushFollow(FOLLOW_statementexpressionlist_in_forinitializer7404);
						statementexpressionlist534 = statementexpressionlist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_statementexpressionlist
								.add(statementexpressionlist534.getTree());

						// AST REWRITE
						// elements: statementexpressionlist
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1167:5: -> ^( ForInitializer statementexpressionlist )
							{
								// ../rsc/CSharp.g3:1167:8: ^( ForInitializer statementexpressionlist )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ForInitializer,
												"ForInitializer"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_statementexpressionlist
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "forinitializer"

	public static class forcondition_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "forcondition"
	// ../rsc/CSharp.g3:1170:1: forcondition : booleanexpression -> ^( ForCondition booleanexpression ) ;
	public final CSharpParser.forcondition_return forcondition()
			throws RecognitionException {
		CSharpParser.forcondition_return retval =
			new CSharpParser.forcondition_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.booleanexpression_return booleanexpression535 = null;

		RewriteRuleSubtreeStream stream_booleanexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule booleanexpression");
		try {
			// ../rsc/CSharp.g3:1171:5: ( booleanexpression -> ^( ForCondition booleanexpression ) )
			// ../rsc/CSharp.g3:1171:9: booleanexpression
			{
				pushFollow(FOLLOW_booleanexpression_in_forcondition7435);
				booleanexpression535 = booleanexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_booleanexpression
						.add(booleanexpression535.getTree());

				// AST REWRITE
				// elements: booleanexpression
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1172:5: -> ^( ForCondition booleanexpression )
					{
						// ../rsc/CSharp.g3:1172:8: ^( ForCondition booleanexpression )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ForCondition,
										"ForCondition"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_booleanexpression.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "forcondition"

	public static class foriterator_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "foriterator"
	// ../rsc/CSharp.g3:1175:1: foriterator : statementexpressionlist -> ^( ForIterator statementexpressionlist ) ;
	public final CSharpParser.foriterator_return foriterator()
			throws RecognitionException {
		CSharpParser.foriterator_return retval =
			new CSharpParser.foriterator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.statementexpressionlist_return statementexpressionlist536 =
			null;

		RewriteRuleSubtreeStream stream_statementexpressionlist =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule statementexpressionlist");
		try {
			// ../rsc/CSharp.g3:1176:5: ( statementexpressionlist -> ^( ForIterator statementexpressionlist ) )
			// ../rsc/CSharp.g3:1176:9: statementexpressionlist
			{
				pushFollow(FOLLOW_statementexpressionlist_in_foriterator7466);
				statementexpressionlist536 = statementexpressionlist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_statementexpressionlist
						.add(statementexpressionlist536.getTree());

				// AST REWRITE
				// elements: statementexpressionlist
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1177:5: -> ^( ForIterator statementexpressionlist )
					{
						// ../rsc/CSharp.g3:1177:8: ^( ForIterator statementexpressionlist )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										ForIterator,
										"ForIterator"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_statementexpressionlist.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "foriterator"

	public static class statementexpressionlist_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "statementexpressionlist"
	// ../rsc/CSharp.g3:1180:1: statementexpressionlist : statementexpression ( cOMMA statementexpression )* ;
	public final CSharpParser.statementexpressionlist_return statementexpressionlist()
			throws RecognitionException {
		CSharpParser.statementexpressionlist_return retval =
			new CSharpParser.statementexpressionlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.statementexpression_return statementexpression537 = null;

		CSharpParser.cOMMA_return cOMMA538 = null;

		CSharpParser.statementexpression_return statementexpression539 = null;

		try {
			// ../rsc/CSharp.g3:1181:5: ( statementexpression ( cOMMA statementexpression )* )
			// ../rsc/CSharp.g3:1181:9: statementexpression ( cOMMA statementexpression )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_statementexpression_in_statementexpressionlist7497);
				statementexpression537 = statementexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, statementexpression537.getTree());
				// ../rsc/CSharp.g3:1181:29: ( cOMMA statementexpression )*
				loop103: do {
					int alt103 = 2;
					int LA103_0 = this.input.LA(1);

					if ((LA103_0 == COMMA)) {
						alt103 = 1;
					}

					switch (alt103) {
						case 1 :
						// ../rsc/CSharp.g3:1181:30: cOMMA statementexpression
							{
								pushFollow(FOLLOW_cOMMA_in_statementexpressionlist7500);
								cOMMA538 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor
										.addChild(root_0, cOMMA538.getTree());
								pushFollow(FOLLOW_statementexpression_in_statementexpressionlist7502);
								statementexpression539 = statementexpression();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										statementexpression539.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "statementexpressionlist"

	public static class foreachstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "foreachstatement"
	// ../rsc/CSharp.g3:1184:1: foreachstatement : fOREACH lPAREN type identifier iN expression rPAREN embeddedstatement -> ^( ForEachStatement fOREACH lPAREN type identifier iN expression rPAREN embeddedstatement ) ;
	public final CSharpParser.foreachstatement_return foreachstatement()
			throws RecognitionException {
		CSharpParser.foreachstatement_return retval =
			new CSharpParser.foreachstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.fOREACH_return fOREACH540 = null;

		CSharpParser.lPAREN_return lPAREN541 = null;

		CSharpParser.type_return type542 = null;

		CSharpParser.identifier_return identifier543 = null;

		CSharpParser.iN_return iN544 = null;

		CSharpParser.expression_return expression545 = null;

		CSharpParser.rPAREN_return rPAREN546 = null;

		CSharpParser.embeddedstatement_return embeddedstatement547 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_fOREACH =
			new RewriteRuleSubtreeStream(this.adaptor, "rule fOREACH");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_embeddedstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule embeddedstatement");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_iN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule iN");
		try {
			// ../rsc/CSharp.g3:1185:5: ( fOREACH lPAREN type identifier iN expression rPAREN embeddedstatement -> ^( ForEachStatement fOREACH lPAREN type identifier iN expression rPAREN embeddedstatement ) )
			// ../rsc/CSharp.g3:1185:9: fOREACH lPAREN type identifier iN expression rPAREN embeddedstatement
			{
				pushFollow(FOLLOW_fOREACH_in_foreachstatement7523);
				fOREACH540 = fOREACH();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_fOREACH.add(fOREACH540.getTree());
				pushFollow(FOLLOW_lPAREN_in_foreachstatement7525);
				lPAREN541 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN541.getTree());
				pushFollow(FOLLOW_type_in_foreachstatement7527);
				type542 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type542.getTree());
				pushFollow(FOLLOW_identifier_in_foreachstatement7529);
				identifier543 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier543.getTree());
				pushFollow(FOLLOW_iN_in_foreachstatement7531);
				iN544 = iN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_iN.add(iN544.getTree());
				pushFollow(FOLLOW_expression_in_foreachstatement7533);
				expression545 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression545.getTree());
				pushFollow(FOLLOW_rPAREN_in_foreachstatement7535);
				rPAREN546 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN546.getTree());
				pushFollow(FOLLOW_embeddedstatement_in_foreachstatement7537);
				embeddedstatement547 = embeddedstatement();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_embeddedstatement
						.add(embeddedstatement547.getTree());

				// AST REWRITE
				// elements: fOREACH, type, expression, rPAREN, iN, identifier, embeddedstatement, lPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1186:5: -> ^( ForEachStatement fOREACH lPAREN type identifier iN expression rPAREN embeddedstatement )
					{
						// ../rsc/CSharp.g3:1186:8: ^( ForEachStatement fOREACH lPAREN type identifier iN expression rPAREN embeddedstatement )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ForEachStatement,
										"ForEachStatement"), root_1);

							this.adaptor.addChild(root_1, stream_fOREACH.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							this.adaptor.addChild(root_1, stream_iN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_embeddedstatement.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "foreachstatement"

	public static class jumpstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "jumpstatement"
	// ../rsc/CSharp.g3:1189:1: jumpstatement : ( breakstatement | continuestatement | gotostatement | returnstatement | throwstatement );
	public final CSharpParser.jumpstatement_return jumpstatement()
			throws RecognitionException {
		CSharpParser.jumpstatement_return retval =
			new CSharpParser.jumpstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.breakstatement_return breakstatement548 = null;

		CSharpParser.continuestatement_return continuestatement549 = null;

		CSharpParser.gotostatement_return gotostatement550 = null;

		CSharpParser.returnstatement_return returnstatement551 = null;

		CSharpParser.throwstatement_return throwstatement552 = null;

		try {
			// ../rsc/CSharp.g3:1190:5: ( breakstatement | continuestatement | gotostatement | returnstatement | throwstatement )
			int alt104 = 5;
			switch (this.input.LA(1)) {
				case BREAK :
					{
						alt104 = 1;
					}
					break;
				case CONTINUE :
					{
						alt104 = 2;
					}
					break;
				case GOTO :
					{
						alt104 = 3;
					}
					break;
				case RETURN :
					{
						alt104 = 4;
					}
					break;
				case THROW :
					{
						alt104 = 5;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 104, 0, this.input);

					throw nvae;
			}

			switch (alt104) {
				case 1 :
				// ../rsc/CSharp.g3:1190:9: breakstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_breakstatement_in_jumpstatement7582);
						breakstatement548 = breakstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								breakstatement548.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1191:9: continuestatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_continuestatement_in_jumpstatement7592);
						continuestatement549 = continuestatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								continuestatement549.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1192:9: gotostatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_gotostatement_in_jumpstatement7602);
						gotostatement550 = gotostatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor
								.addChild(root_0, gotostatement550.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1193:9: returnstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_returnstatement_in_jumpstatement7612);
						returnstatement551 = returnstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								returnstatement551.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1194:9: throwstatement
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_throwstatement_in_jumpstatement7622);
						throwstatement552 = throwstatement();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								throwstatement552.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "jumpstatement"

	public static class breakstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "breakstatement"
	// ../rsc/CSharp.g3:1197:1: breakstatement : bREAK sEMICOLON -> ^( BreakStatement bREAK sEMICOLON ) ;
	public final CSharpParser.breakstatement_return breakstatement()
			throws RecognitionException {
		CSharpParser.breakstatement_return retval =
			new CSharpParser.breakstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.bREAK_return bREAK553 = null;

		CSharpParser.sEMICOLON_return sEMICOLON554 = null;

		RewriteRuleSubtreeStream stream_bREAK =
			new RewriteRuleSubtreeStream(this.adaptor, "rule bREAK");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1198:5: ( bREAK sEMICOLON -> ^( BreakStatement bREAK sEMICOLON ) )
			// ../rsc/CSharp.g3:1198:9: bREAK sEMICOLON
			{
				pushFollow(FOLLOW_bREAK_in_breakstatement7641);
				bREAK553 = bREAK();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_bREAK.add(bREAK553.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_breakstatement7643);
				sEMICOLON554 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON554.getTree());

				// AST REWRITE
				// elements: sEMICOLON, bREAK
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1199:5: -> ^( BreakStatement bREAK sEMICOLON )
					{
						// ../rsc/CSharp.g3:1199:8: ^( BreakStatement bREAK sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										BreakStatement,
										"BreakStatement"),
									root_1);

							this.adaptor.addChild(root_1, stream_bREAK.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "breakstatement"

	public static class continuestatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "continuestatement"
	// ../rsc/CSharp.g3:1202:1: continuestatement : cONTINUE sEMICOLON -> ^( ContinueStatement cONTINUE sEMICOLON ) ;
	public final CSharpParser.continuestatement_return continuestatement()
			throws RecognitionException {
		CSharpParser.continuestatement_return retval =
			new CSharpParser.continuestatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cONTINUE_return cONTINUE555 = null;

		CSharpParser.sEMICOLON_return sEMICOLON556 = null;

		RewriteRuleSubtreeStream stream_cONTINUE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cONTINUE");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1203:5: ( cONTINUE sEMICOLON -> ^( ContinueStatement cONTINUE sEMICOLON ) )
			// ../rsc/CSharp.g3:1203:9: cONTINUE sEMICOLON
			{
				pushFollow(FOLLOW_cONTINUE_in_continuestatement7676);
				cONTINUE555 = cONTINUE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cONTINUE.add(cONTINUE555.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_continuestatement7678);
				sEMICOLON556 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON556.getTree());

				// AST REWRITE
				// elements: cONTINUE, sEMICOLON
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1204:5: -> ^( ContinueStatement cONTINUE sEMICOLON )
					{
						// ../rsc/CSharp.g3:1204:8: ^( ContinueStatement cONTINUE sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ContinueStatement,
										"ContinueStatement"), root_1);

							this.adaptor
								.addChild(root_1, stream_cONTINUE.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "continuestatement"

	public static class gotostatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "gotostatement"
	// ../rsc/CSharp.g3:1207:1: gotostatement : ( gOTO identifier sEMICOLON -> ^( GotoStatement gOTO identifier sEMICOLON ) | gOTO cASE constantexpression sEMICOLON -> ^( GotoStatement gOTO cASE constantexpression sEMICOLON ) | gOTO dEFAULT sEMICOLON -> ^( GotoStatement gOTO dEFAULT sEMICOLON ) );
	public final CSharpParser.gotostatement_return gotostatement()
			throws RecognitionException {
		CSharpParser.gotostatement_return retval =
			new CSharpParser.gotostatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.gOTO_return gOTO557 = null;

		CSharpParser.identifier_return identifier558 = null;

		CSharpParser.sEMICOLON_return sEMICOLON559 = null;

		CSharpParser.gOTO_return gOTO560 = null;

		CSharpParser.cASE_return cASE561 = null;

		CSharpParser.constantexpression_return constantexpression562 = null;

		CSharpParser.sEMICOLON_return sEMICOLON563 = null;

		CSharpParser.gOTO_return gOTO564 = null;

		CSharpParser.dEFAULT_return dEFAULT565 = null;

		CSharpParser.sEMICOLON_return sEMICOLON566 = null;

		RewriteRuleSubtreeStream stream_dEFAULT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dEFAULT");
		RewriteRuleSubtreeStream stream_constantexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantexpression");
		RewriteRuleSubtreeStream stream_gOTO =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gOTO");
		RewriteRuleSubtreeStream stream_cASE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cASE");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1208:5: ( gOTO identifier sEMICOLON -> ^( GotoStatement gOTO identifier sEMICOLON ) | gOTO cASE constantexpression sEMICOLON -> ^( GotoStatement gOTO cASE constantexpression sEMICOLON ) | gOTO dEFAULT sEMICOLON -> ^( GotoStatement gOTO dEFAULT sEMICOLON ) )
			int alt105 = 3;
			alt105 = this.dfa105.predict(this.input);
			switch (alt105) {
				case 1 :
				// ../rsc/CSharp.g3:1208:9: gOTO identifier sEMICOLON
					{
						pushFollow(FOLLOW_gOTO_in_gotostatement7711);
						gOTO557 = gOTO();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_gOTO.add(gOTO557.getTree());
						pushFollow(FOLLOW_identifier_in_gotostatement7713);
						identifier558 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier558.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_gotostatement7715);
						sEMICOLON559 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON559.getTree());

						// AST REWRITE
						// elements: identifier, gOTO, sEMICOLON
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1209:5: -> ^( GotoStatement gOTO identifier sEMICOLON )
							{
								// ../rsc/CSharp.g3:1209:8: ^( GotoStatement gOTO identifier sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												GotoStatement,
												"GotoStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_gOTO.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1210:9: gOTO cASE constantexpression sEMICOLON
					{
						pushFollow(FOLLOW_gOTO_in_gotostatement7741);
						gOTO560 = gOTO();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_gOTO.add(gOTO560.getTree());
						pushFollow(FOLLOW_cASE_in_gotostatement7743);
						cASE561 = cASE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cASE.add(cASE561.getTree());
						pushFollow(FOLLOW_constantexpression_in_gotostatement7745);
						constantexpression562 = constantexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constantexpression.add(constantexpression562
								.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_gotostatement7747);
						sEMICOLON563 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON563.getTree());

						// AST REWRITE
						// elements: gOTO, sEMICOLON, cASE, constantexpression
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1211:5: -> ^( GotoStatement gOTO cASE constantexpression sEMICOLON )
							{
								// ../rsc/CSharp.g3:1211:8: ^( GotoStatement gOTO cASE constantexpression sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												GotoStatement,
												"GotoStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_gOTO.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cASE.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_constantexpression.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1212:9: gOTO dEFAULT sEMICOLON
					{
						pushFollow(FOLLOW_gOTO_in_gotostatement7775);
						gOTO564 = gOTO();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_gOTO.add(gOTO564.getTree());
						pushFollow(FOLLOW_dEFAULT_in_gotostatement7777);
						dEFAULT565 = dEFAULT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_dEFAULT.add(dEFAULT565.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_gotostatement7779);
						sEMICOLON566 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON566.getTree());

						// AST REWRITE
						// elements: dEFAULT, sEMICOLON, gOTO
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1213:5: -> ^( GotoStatement gOTO dEFAULT sEMICOLON )
							{
								// ../rsc/CSharp.g3:1213:8: ^( GotoStatement gOTO dEFAULT sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												GotoStatement,
												"GotoStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_gOTO.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_dEFAULT.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "gotostatement"

	public static class returnstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "returnstatement"
	// ../rsc/CSharp.g3:1216:1: returnstatement : rETURN ( expression )? sEMICOLON -> ^( ReturnStatement rETURN ( expression )? sEMICOLON ) ;
	public final CSharpParser.returnstatement_return returnstatement()
			throws RecognitionException {
		CSharpParser.returnstatement_return retval =
			new CSharpParser.returnstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.rETURN_return rETURN567 = null;

		CSharpParser.expression_return expression568 = null;

		CSharpParser.sEMICOLON_return sEMICOLON569 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_rETURN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rETURN");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1217:5: ( rETURN ( expression )? sEMICOLON -> ^( ReturnStatement rETURN ( expression )? sEMICOLON ) )
			// ../rsc/CSharp.g3:1217:9: rETURN ( expression )? sEMICOLON
			{
				pushFollow(FOLLOW_rETURN_in_returnstatement7814);
				rETURN567 = rETURN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rETURN.add(rETURN567.getTree());
				// ../rsc/CSharp.g3:1217:16: ( expression )?
				int alt106 = 2;
				int LA106_0 = this.input.LA(1);

				if ((LA106_0 == LPAREN || (LA106_0 >= PLUS && LA106_0 <= MINUS)
						|| (LA106_0 >= EXCLAM && LA106_0 <= TILDE)
						|| (LA106_0 >= INCREMENT && LA106_0 <= DECREMENT)
						|| (LA106_0 >= BASE && LA106_0 <= BOOL)
						|| LA106_0 == BYTE
						|| (LA106_0 >= CHAR && LA106_0 <= CHECKED)
						|| (LA106_0 >= DECIMAL && LA106_0 <= DELEGATE)
						|| LA106_0 == DOUBLE || LA106_0 == FALSE
						|| LA106_0 == FLOAT || LA106_0 == INT
						|| LA106_0 == LONG
						|| (LA106_0 >= NEW && LA106_0 <= OBJECT)
						|| LA106_0 == SBYTE || LA106_0 == SHORT
						|| LA106_0 == STRING || LA106_0 == THIS
						|| LA106_0 == TRUE
						|| (LA106_0 >= TYPEOF && LA106_0 <= UNCHECKED)
						|| LA106_0 == USHORT || (LA106_0 >= ADD && LA106_0 <= Stringliteral))) {
					alt106 = 1;
				}
				switch (alt106) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: expression
						{
							pushFollow(FOLLOW_expression_in_returnstatement7816);
							expression568 = expression();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_expression.add(expression568.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_sEMICOLON_in_returnstatement7819);
				sEMICOLON569 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON569.getTree());

				// AST REWRITE
				// elements: expression, sEMICOLON, rETURN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1218:5: -> ^( ReturnStatement rETURN ( expression )? sEMICOLON )
					{
						// ../rsc/CSharp.g3:1218:8: ^( ReturnStatement rETURN ( expression )? sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ReturnStatement,
										"ReturnStatement"),
									root_1);

							this.adaptor.addChild(root_1, stream_rETURN.nextTree());
							// ../rsc/CSharp.g3:1218:33: ( expression )?
							if (stream_expression.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_expression.nextTree());

							}
							stream_expression.reset();
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "returnstatement"

	public static class throwstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "throwstatement"
	// ../rsc/CSharp.g3:1221:1: throwstatement : tHROW ( expression )? sEMICOLON -> ^( ThrowStatement tHROW ( expression )? sEMICOLON ) ;
	public final CSharpParser.throwstatement_return throwstatement()
			throws RecognitionException {
		CSharpParser.throwstatement_return retval =
			new CSharpParser.throwstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.tHROW_return tHROW570 = null;

		CSharpParser.expression_return expression571 = null;

		CSharpParser.sEMICOLON_return sEMICOLON572 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_tHROW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule tHROW");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1222:5: ( tHROW ( expression )? sEMICOLON -> ^( ThrowStatement tHROW ( expression )? sEMICOLON ) )
			// ../rsc/CSharp.g3:1222:9: tHROW ( expression )? sEMICOLON
			{
				pushFollow(FOLLOW_tHROW_in_throwstatement7855);
				tHROW570 = tHROW();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_tHROW.add(tHROW570.getTree());
				// ../rsc/CSharp.g3:1222:15: ( expression )?
				int alt107 = 2;
				int LA107_0 = this.input.LA(1);

				if ((LA107_0 == LPAREN || (LA107_0 >= PLUS && LA107_0 <= MINUS)
						|| (LA107_0 >= EXCLAM && LA107_0 <= TILDE)
						|| (LA107_0 >= INCREMENT && LA107_0 <= DECREMENT)
						|| (LA107_0 >= BASE && LA107_0 <= BOOL)
						|| LA107_0 == BYTE
						|| (LA107_0 >= CHAR && LA107_0 <= CHECKED)
						|| (LA107_0 >= DECIMAL && LA107_0 <= DELEGATE)
						|| LA107_0 == DOUBLE || LA107_0 == FALSE
						|| LA107_0 == FLOAT || LA107_0 == INT
						|| LA107_0 == LONG
						|| (LA107_0 >= NEW && LA107_0 <= OBJECT)
						|| LA107_0 == SBYTE || LA107_0 == SHORT
						|| LA107_0 == STRING || LA107_0 == THIS
						|| LA107_0 == TRUE
						|| (LA107_0 >= TYPEOF && LA107_0 <= UNCHECKED)
						|| LA107_0 == USHORT || (LA107_0 >= ADD && LA107_0 <= Stringliteral))) {
					alt107 = 1;
				}
				switch (alt107) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: expression
						{
							pushFollow(FOLLOW_expression_in_throwstatement7857);
							expression571 = expression();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_expression.add(expression571.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_sEMICOLON_in_throwstatement7860);
				sEMICOLON572 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON572.getTree());

				// AST REWRITE
				// elements: tHROW, expression, sEMICOLON
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1223:5: -> ^( ThrowStatement tHROW ( expression )? sEMICOLON )
					{
						// ../rsc/CSharp.g3:1223:8: ^( ThrowStatement tHROW ( expression )? sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ThrowStatement,
										"ThrowStatement"),
									root_1);

							this.adaptor.addChild(root_1, stream_tHROW.nextTree());
							// ../rsc/CSharp.g3:1223:31: ( expression )?
							if (stream_expression.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_expression.nextTree());

							}
							stream_expression.reset();
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "throwstatement"

	public static class trystatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "trystatement"
	// ../rsc/CSharp.g3:1226:1: trystatement : ( tRY block ( catchclauses )? finallyclause -> ^( TryStatement ^( TryBlock tRY block ) ( catchclauses )? finallyclause ) | tRY block catchclauses -> ^( TryStatement ^( TryBlock tRY block ) catchclauses ) );
	public final CSharpParser.trystatement_return trystatement()
			throws RecognitionException {
		CSharpParser.trystatement_return retval =
			new CSharpParser.trystatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.tRY_return tRY573 = null;

		CSharpParser.block_return block574 = null;

		CSharpParser.catchclauses_return catchclauses575 = null;

		CSharpParser.finallyclause_return finallyclause576 = null;

		CSharpParser.tRY_return tRY577 = null;

		CSharpParser.block_return block578 = null;

		CSharpParser.catchclauses_return catchclauses579 = null;

		RewriteRuleSubtreeStream stream_tRY =
			new RewriteRuleSubtreeStream(this.adaptor, "rule tRY");
		RewriteRuleSubtreeStream stream_catchclauses =
			new RewriteRuleSubtreeStream(this.adaptor, "rule catchclauses");
		RewriteRuleSubtreeStream stream_finallyclause =
			new RewriteRuleSubtreeStream(this.adaptor, "rule finallyclause");
		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		try {
			// ../rsc/CSharp.g3:1227:5: ( tRY block ( catchclauses )? finallyclause -> ^( TryStatement ^( TryBlock tRY block ) ( catchclauses )? finallyclause ) | tRY block catchclauses -> ^( TryStatement ^( TryBlock tRY block ) catchclauses ) )
			int alt109 = 2;
			int LA109_0 = this.input.LA(1);

			if ((LA109_0 == TRY)) {
				this.input.LA(2);

				if ((synpred297_CSharp())) {
					alt109 = 1;
				}
				else if ((true)) {
					alt109 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 109, 0, this.input);

				throw nvae;
			}
			switch (alt109) {
				case 1 :
				// ../rsc/CSharp.g3:1227:9: tRY block ( catchclauses )? finallyclause
					{
						pushFollow(FOLLOW_tRY_in_trystatement7896);
						tRY573 = tRY();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_tRY.add(tRY573.getTree());
						pushFollow(FOLLOW_block_in_trystatement7898);
						block574 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_block.add(block574.getTree());
						// ../rsc/CSharp.g3:1227:19: ( catchclauses )?
						int alt108 = 2;
						int LA108_0 = this.input.LA(1);

						if ((LA108_0 == CATCH)) {
							alt108 = 1;
						}
						switch (alt108) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: catchclauses
								{
									pushFollow(FOLLOW_catchclauses_in_trystatement7900);
									catchclauses575 = catchclauses();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_catchclauses.add(catchclauses575
											.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_finallyclause_in_trystatement7903);
						finallyclause576 = finallyclause();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_finallyclause
								.add(finallyclause576.getTree());

						// AST REWRITE
						// elements: finallyclause, catchclauses, block, tRY
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1228:5: -> ^( TryStatement ^( TryBlock tRY block ) ( catchclauses )? finallyclause )
							{
								// ../rsc/CSharp.g3:1228:8: ^( TryStatement ^( TryBlock tRY block ) ( catchclauses )? finallyclause )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TryStatement,
												"TryStatement"),
											root_1);

									// ../rsc/CSharp.g3:1228:23: ^( TryBlock tRY block )
									{
										Object root_2 = (Object) this.adaptor.nil();
										root_2 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													TryBlock,
													"TryBlock"),
												root_2);

										this.adaptor.addChild(
											root_2,
											stream_tRY.nextTree());
										this.adaptor.addChild(
											root_2,
											stream_block.nextTree());

										this.adaptor.addChild(root_1, root_2);
									}
									// ../rsc/CSharp.g3:1228:45: ( catchclauses )?
									if (stream_catchclauses.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_catchclauses.nextTree());

									}
									stream_catchclauses.reset();
									this.adaptor.addChild(
										root_1,
										stream_finallyclause.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1229:9: tRY block catchclauses
					{
						pushFollow(FOLLOW_tRY_in_trystatement7936);
						tRY577 = tRY();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_tRY.add(tRY577.getTree());
						pushFollow(FOLLOW_block_in_trystatement7938);
						block578 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_block.add(block578.getTree());
						pushFollow(FOLLOW_catchclauses_in_trystatement7940);
						catchclauses579 = catchclauses();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_catchclauses.add(catchclauses579.getTree());

						// AST REWRITE
						// elements: catchclauses, tRY, block
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1230:5: -> ^( TryStatement ^( TryBlock tRY block ) catchclauses )
							{
								// ../rsc/CSharp.g3:1230:8: ^( TryStatement ^( TryBlock tRY block ) catchclauses )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TryStatement,
												"TryStatement"),
											root_1);

									// ../rsc/CSharp.g3:1230:23: ^( TryBlock tRY block )
									{
										Object root_2 = (Object) this.adaptor.nil();
										root_2 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													TryBlock,
													"TryBlock"),
												root_2);

										this.adaptor.addChild(
											root_2,
											stream_tRY.nextTree());
										this.adaptor.addChild(
											root_2,
											stream_block.nextTree());

										this.adaptor.addChild(root_1, root_2);
									}
									this.adaptor.addChild(
										root_1,
										stream_catchclauses.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "trystatement"

	public static class catchclauses_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "catchclauses"
	// ../rsc/CSharp.g3:1233:1: catchclauses : ( ( specificcatchclauses )? generalcatchclause | specificcatchclauses );
	public final CSharpParser.catchclauses_return catchclauses()
			throws RecognitionException {
		CSharpParser.catchclauses_return retval =
			new CSharpParser.catchclauses_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.specificcatchclauses_return specificcatchclauses580 = null;

		CSharpParser.generalcatchclause_return generalcatchclause581 = null;

		CSharpParser.specificcatchclauses_return specificcatchclauses582 = null;

		try {
			// ../rsc/CSharp.g3:1234:5: ( ( specificcatchclauses )? generalcatchclause | specificcatchclauses )
			int alt111 = 2;
			int LA111_0 = this.input.LA(1);

			if ((LA111_0 == CATCH)) {
				this.input.LA(2);

				if ((synpred299_CSharp())) {
					alt111 = 1;
				}
				else if ((true)) {
					alt111 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 111, 0, this.input);

				throw nvae;
			}
			switch (alt111) {
				case 1 :
				// ../rsc/CSharp.g3:1234:9: ( specificcatchclauses )? generalcatchclause
					{
						root_0 = (Object) this.adaptor.nil();

						// ../rsc/CSharp.g3:1234:9: ( specificcatchclauses )?
						int alt110 = 2;
						alt110 = this.dfa110.predict(this.input);
						switch (alt110) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: specificcatchclauses
								{
									pushFollow(FOLLOW_specificcatchclauses_in_catchclauses7979);
									specificcatchclauses580 =
										specificcatchclauses();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										this.adaptor.addChild(
											root_0,
											specificcatchclauses580.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_generalcatchclause_in_catchclauses7982);
						generalcatchclause581 = generalcatchclause();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								generalcatchclause581.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1235:9: specificcatchclauses
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_specificcatchclauses_in_catchclauses7992);
						specificcatchclauses582 = specificcatchclauses();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								specificcatchclauses582.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "catchclauses"

	public static class specificcatchclauses_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "specificcatchclauses"
	// ../rsc/CSharp.g3:1238:1: specificcatchclauses : ( specificcatchclause )+ ;
	public final CSharpParser.specificcatchclauses_return specificcatchclauses()
			throws RecognitionException {
		CSharpParser.specificcatchclauses_return retval =
			new CSharpParser.specificcatchclauses_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.specificcatchclause_return specificcatchclause583 = null;

		try {
			// ../rsc/CSharp.g3:1239:5: ( ( specificcatchclause )+ )
			// ../rsc/CSharp.g3:1239:9: ( specificcatchclause )+
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:1239:9: ( specificcatchclause )+
				int cnt112 = 0;
				loop112: do {
					int alt112 = 2;
					alt112 = this.dfa112.predict(this.input);
					switch (alt112) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: specificcatchclause
							{
								pushFollow(FOLLOW_specificcatchclause_in_specificcatchclauses8012);
								specificcatchclause583 = specificcatchclause();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										specificcatchclause583.getTree());

							}
							break;

						default :
							if (cnt112 >= 1)
								break loop112;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(112, this.input);
							throw eee;
					}
					cnt112++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "specificcatchclauses"

	public static class specificcatchclause_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "specificcatchclause"
	// ../rsc/CSharp.g3:1242:1: specificcatchclause : cATCH lPAREN classtype ( identifier )? rPAREN block -> ^( CatchClause cATCH lPAREN classtype ( identifier )? rPAREN block ) ;
	public final CSharpParser.specificcatchclause_return specificcatchclause()
			throws RecognitionException {
		CSharpParser.specificcatchclause_return retval =
			new CSharpParser.specificcatchclause_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cATCH_return cATCH584 = null;

		CSharpParser.lPAREN_return lPAREN585 = null;

		CSharpParser.classtype_return classtype586 = null;

		CSharpParser.identifier_return identifier587 = null;

		CSharpParser.rPAREN_return rPAREN588 = null;

		CSharpParser.block_return block589 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_classtype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classtype");
		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		RewriteRuleSubtreeStream stream_cATCH =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cATCH");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:1243:5: ( cATCH lPAREN classtype ( identifier )? rPAREN block -> ^( CatchClause cATCH lPAREN classtype ( identifier )? rPAREN block ) )
			// ../rsc/CSharp.g3:1243:9: cATCH lPAREN classtype ( identifier )? rPAREN block
			{
				pushFollow(FOLLOW_cATCH_in_specificcatchclause8032);
				cATCH584 = cATCH();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cATCH.add(cATCH584.getTree());
				pushFollow(FOLLOW_lPAREN_in_specificcatchclause8034);
				lPAREN585 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN585.getTree());
				pushFollow(FOLLOW_classtype_in_specificcatchclause8036);
				classtype586 = classtype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_classtype.add(classtype586.getTree());
				// ../rsc/CSharp.g3:1243:32: ( identifier )?
				int alt113 = 2;
				int LA113_0 = this.input.LA(1);

				if (((LA113_0 >= ADD && LA113_0 <= Ident))) {
					alt113 = 1;
				}
				switch (alt113) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: identifier
						{
							pushFollow(FOLLOW_identifier_in_specificcatchclause8038);
							identifier587 = identifier();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_identifier.add(identifier587.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_specificcatchclause8041);
				rPAREN588 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN588.getTree());
				pushFollow(FOLLOW_block_in_specificcatchclause8043);
				block589 = block();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_block.add(block589.getTree());

				// AST REWRITE
				// elements: rPAREN, classtype, block, cATCH, lPAREN, identifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1244:5: -> ^( CatchClause cATCH lPAREN classtype ( identifier )? rPAREN block )
					{
						// ../rsc/CSharp.g3:1244:8: ^( CatchClause cATCH lPAREN classtype ( identifier )? rPAREN block )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										CatchClause,
										"CatchClause"), root_1);

							this.adaptor.addChild(root_1, stream_cATCH.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_classtype.nextTree());
							// ../rsc/CSharp.g3:1244:45: ( identifier )?
							if (stream_identifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_identifier.nextTree());

							}
							stream_identifier.reset();
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							this.adaptor.addChild(root_1, stream_block.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "specificcatchclause"

	public static class generalcatchclause_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "generalcatchclause"
	// ../rsc/CSharp.g3:1247:1: generalcatchclause : cATCH block -> ^( CatchClause cATCH block ) ;
	public final CSharpParser.generalcatchclause_return generalcatchclause()
			throws RecognitionException {
		CSharpParser.generalcatchclause_return retval =
			new CSharpParser.generalcatchclause_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cATCH_return cATCH590 = null;

		CSharpParser.block_return block591 = null;

		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		RewriteRuleSubtreeStream stream_cATCH =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cATCH");
		try {
			// ../rsc/CSharp.g3:1248:5: ( cATCH block -> ^( CatchClause cATCH block ) )
			// ../rsc/CSharp.g3:1248:9: cATCH block
			{
				pushFollow(FOLLOW_cATCH_in_generalcatchclause8085);
				cATCH590 = cATCH();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cATCH.add(cATCH590.getTree());
				pushFollow(FOLLOW_block_in_generalcatchclause8087);
				block591 = block();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_block.add(block591.getTree());

				// AST REWRITE
				// elements: cATCH, block
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1249:5: -> ^( CatchClause cATCH block )
					{
						// ../rsc/CSharp.g3:1249:8: ^( CatchClause cATCH block )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										CatchClause,
										"CatchClause"), root_1);

							this.adaptor.addChild(root_1, stream_cATCH.nextTree());
							this.adaptor.addChild(root_1, stream_block.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "generalcatchclause"

	public static class finallyclause_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "finallyclause"
	// ../rsc/CSharp.g3:1253:1: finallyclause : fINALLY block -> ^( FinallyClause fINALLY block ) ;
	public final CSharpParser.finallyclause_return finallyclause()
			throws RecognitionException {
		CSharpParser.finallyclause_return retval =
			new CSharpParser.finallyclause_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.fINALLY_return fINALLY592 = null;

		CSharpParser.block_return block593 = null;

		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		RewriteRuleSubtreeStream stream_fINALLY =
			new RewriteRuleSubtreeStream(this.adaptor, "rule fINALLY");
		try {
			// ../rsc/CSharp.g3:1254:5: ( fINALLY block -> ^( FinallyClause fINALLY block ) )
			// ../rsc/CSharp.g3:1254:9: fINALLY block
			{
				pushFollow(FOLLOW_fINALLY_in_finallyclause8121);
				fINALLY592 = fINALLY();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_fINALLY.add(fINALLY592.getTree());
				pushFollow(FOLLOW_block_in_finallyclause8123);
				block593 = block();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_block.add(block593.getTree());

				// AST REWRITE
				// elements: block, fINALLY
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1255:5: -> ^( FinallyClause fINALLY block )
					{
						// ../rsc/CSharp.g3:1255:8: ^( FinallyClause fINALLY block )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										FinallyClause,
										"FinallyClause"),
									root_1);

							this.adaptor.addChild(root_1, stream_fINALLY.nextTree());
							this.adaptor.addChild(root_1, stream_block.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "finallyclause"

	public static class checkedstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "checkedstatement"
	// ../rsc/CSharp.g3:1258:1: checkedstatement : cHECKED block -> ^( CheckedStatement cHECKED block ) ;
	public final CSharpParser.checkedstatement_return checkedstatement()
			throws RecognitionException {
		CSharpParser.checkedstatement_return retval =
			new CSharpParser.checkedstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cHECKED_return cHECKED594 = null;

		CSharpParser.block_return block595 = null;

		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		RewriteRuleSubtreeStream stream_cHECKED =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cHECKED");
		try {
			// ../rsc/CSharp.g3:1259:5: ( cHECKED block -> ^( CheckedStatement cHECKED block ) )
			// ../rsc/CSharp.g3:1259:9: cHECKED block
			{
				pushFollow(FOLLOW_cHECKED_in_checkedstatement8156);
				cHECKED594 = cHECKED();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cHECKED.add(cHECKED594.getTree());
				pushFollow(FOLLOW_block_in_checkedstatement8158);
				block595 = block();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_block.add(block595.getTree());

				// AST REWRITE
				// elements: block, cHECKED
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1260:5: -> ^( CheckedStatement cHECKED block )
					{
						// ../rsc/CSharp.g3:1260:8: ^( CheckedStatement cHECKED block )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										CheckedStatement,
										"CheckedStatement"), root_1);

							this.adaptor.addChild(root_1, stream_cHECKED.nextTree());
							this.adaptor.addChild(root_1, stream_block.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "checkedstatement"

	public static class uncheckedstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "uncheckedstatement"
	// ../rsc/CSharp.g3:1263:1: uncheckedstatement : uNCHECKED block -> ^( UncheckedStatement uNCHECKED block ) ;
	public final CSharpParser.uncheckedstatement_return uncheckedstatement()
			throws RecognitionException {
		CSharpParser.uncheckedstatement_return retval =
			new CSharpParser.uncheckedstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.uNCHECKED_return uNCHECKED596 = null;

		CSharpParser.block_return block597 = null;

		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		RewriteRuleSubtreeStream stream_uNCHECKED =
			new RewriteRuleSubtreeStream(this.adaptor, "rule uNCHECKED");
		try {
			// ../rsc/CSharp.g3:1264:5: ( uNCHECKED block -> ^( UncheckedStatement uNCHECKED block ) )
			// ../rsc/CSharp.g3:1264:9: uNCHECKED block
			{
				pushFollow(FOLLOW_uNCHECKED_in_uncheckedstatement8191);
				uNCHECKED596 = uNCHECKED();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_uNCHECKED.add(uNCHECKED596.getTree());
				pushFollow(FOLLOW_block_in_uncheckedstatement8193);
				block597 = block();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_block.add(block597.getTree());

				// AST REWRITE
				// elements: block, uNCHECKED
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1265:5: -> ^( UncheckedStatement uNCHECKED block )
					{
						// ../rsc/CSharp.g3:1265:8: ^( UncheckedStatement uNCHECKED block )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										UncheckedStatement,
										"UncheckedStatement"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_uNCHECKED.nextTree());
							this.adaptor.addChild(root_1, stream_block.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "uncheckedstatement"

	public static class lockstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lockstatement"
	// ../rsc/CSharp.g3:1268:1: lockstatement : lOCK lPAREN expression rPAREN embeddedstatement -> ^( LockStatement lOCK lPAREN expression rPAREN embeddedstatement ) ;
	public final CSharpParser.lockstatement_return lockstatement()
			throws RecognitionException {
		CSharpParser.lockstatement_return retval =
			new CSharpParser.lockstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lOCK_return lOCK598 = null;

		CSharpParser.lPAREN_return lPAREN599 = null;

		CSharpParser.expression_return expression600 = null;

		CSharpParser.rPAREN_return rPAREN601 = null;

		CSharpParser.embeddedstatement_return embeddedstatement602 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_embeddedstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule embeddedstatement");
		RewriteRuleSubtreeStream stream_lOCK =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lOCK");
		try {
			// ../rsc/CSharp.g3:1269:5: ( lOCK lPAREN expression rPAREN embeddedstatement -> ^( LockStatement lOCK lPAREN expression rPAREN embeddedstatement ) )
			// ../rsc/CSharp.g3:1269:9: lOCK lPAREN expression rPAREN embeddedstatement
			{
				pushFollow(FOLLOW_lOCK_in_lockstatement8226);
				lOCK598 = lOCK();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lOCK.add(lOCK598.getTree());
				pushFollow(FOLLOW_lPAREN_in_lockstatement8228);
				lPAREN599 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN599.getTree());
				pushFollow(FOLLOW_expression_in_lockstatement8230);
				expression600 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_expression.add(expression600.getTree());
				pushFollow(FOLLOW_rPAREN_in_lockstatement8232);
				rPAREN601 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN601.getTree());
				pushFollow(FOLLOW_embeddedstatement_in_lockstatement8234);
				embeddedstatement602 = embeddedstatement();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_embeddedstatement
						.add(embeddedstatement602.getTree());

				// AST REWRITE
				// elements: embeddedstatement, lPAREN, rPAREN, lOCK, expression
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1270:5: -> ^( LockStatement lOCK lPAREN expression rPAREN embeddedstatement )
					{
						// ../rsc/CSharp.g3:1270:8: ^( LockStatement lOCK lPAREN expression rPAREN embeddedstatement )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										LockStatement,
										"LockStatement"),
									root_1);

							this.adaptor.addChild(root_1, stream_lOCK.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_expression.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_embeddedstatement.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lockstatement"

	public static class usingstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "usingstatement"
	// ../rsc/CSharp.g3:1273:1: usingstatement : uSING lPAREN resourceacquisition rPAREN embeddedstatement -> ^( UsingStatement uSING lPAREN resourceacquisition rPAREN embeddedstatement ) ;
	public final CSharpParser.usingstatement_return usingstatement()
			throws RecognitionException {
		CSharpParser.usingstatement_return retval =
			new CSharpParser.usingstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.uSING_return uSING603 = null;

		CSharpParser.lPAREN_return lPAREN604 = null;

		CSharpParser.resourceacquisition_return resourceacquisition605 = null;

		CSharpParser.rPAREN_return rPAREN606 = null;

		CSharpParser.embeddedstatement_return embeddedstatement607 = null;

		RewriteRuleSubtreeStream stream_resourceacquisition =
			new RewriteRuleSubtreeStream(this.adaptor, "rule resourceacquisition");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_uSING =
			new RewriteRuleSubtreeStream(this.adaptor, "rule uSING");
		RewriteRuleSubtreeStream stream_embeddedstatement =
			new RewriteRuleSubtreeStream(this.adaptor, "rule embeddedstatement");
		try {
			// ../rsc/CSharp.g3:1274:5: ( uSING lPAREN resourceacquisition rPAREN embeddedstatement -> ^( UsingStatement uSING lPAREN resourceacquisition rPAREN embeddedstatement ) )
			// ../rsc/CSharp.g3:1274:9: uSING lPAREN resourceacquisition rPAREN embeddedstatement
			{
				pushFollow(FOLLOW_uSING_in_usingstatement8273);
				uSING603 = uSING();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_uSING.add(uSING603.getTree());
				pushFollow(FOLLOW_lPAREN_in_usingstatement8275);
				lPAREN604 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN604.getTree());
				pushFollow(FOLLOW_resourceacquisition_in_usingstatement8277);
				resourceacquisition605 = resourceacquisition();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_resourceacquisition.add(resourceacquisition605
						.getTree());
				pushFollow(FOLLOW_rPAREN_in_usingstatement8279);
				rPAREN606 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN606.getTree());
				pushFollow(FOLLOW_embeddedstatement_in_usingstatement8281);
				embeddedstatement607 = embeddedstatement();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_embeddedstatement
						.add(embeddedstatement607.getTree());

				// AST REWRITE
				// elements: lPAREN, resourceacquisition, embeddedstatement, rPAREN, uSING
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1275:5: -> ^( UsingStatement uSING lPAREN resourceacquisition rPAREN embeddedstatement )
					{
						// ../rsc/CSharp.g3:1275:8: ^( UsingStatement uSING lPAREN resourceacquisition rPAREN embeddedstatement )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										UsingStatement,
										"UsingStatement"),
									root_1);

							this.adaptor.addChild(root_1, stream_uSING.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_resourceacquisition.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_embeddedstatement.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "usingstatement"

	public static class resourceacquisition_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "resourceacquisition"
	// ../rsc/CSharp.g3:1278:1: resourceacquisition : ( localvariabledeclaration | expression );
	public final CSharpParser.resourceacquisition_return resourceacquisition()
			throws RecognitionException {
		CSharpParser.resourceacquisition_return retval =
			new CSharpParser.resourceacquisition_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.localvariabledeclaration_return localvariabledeclaration608 =
			null;

		CSharpParser.expression_return expression609 = null;

		try {
			// ../rsc/CSharp.g3:1279:5: ( localvariabledeclaration | expression )
			int alt114 = 2;
			alt114 = this.dfa114.predict(this.input);
			switch (alt114) {
				case 1 :
				// ../rsc/CSharp.g3:1279:9: localvariabledeclaration
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_localvariabledeclaration_in_resourceacquisition8320);
						localvariabledeclaration608 =
							localvariabledeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								localvariabledeclaration608.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1280:9: expression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_expression_in_resourceacquisition8330);
						expression609 = expression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, expression609.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "resourceacquisition"

	public static class yieldstatement_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "yieldstatement"
	// ../rsc/CSharp.g3:1283:1: yieldstatement : ( yIELD rETURN expression sEMICOLON -> ^( YieldStatement yIELD rETURN expression sEMICOLON ) | yIELD bREAK sEMICOLON -> ^( YieldStatement yIELD bREAK sEMICOLON ) );
	public final CSharpParser.yieldstatement_return yieldstatement()
			throws RecognitionException {
		CSharpParser.yieldstatement_return retval =
			new CSharpParser.yieldstatement_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.yIELD_return yIELD610 = null;

		CSharpParser.rETURN_return rETURN611 = null;

		CSharpParser.expression_return expression612 = null;

		CSharpParser.sEMICOLON_return sEMICOLON613 = null;

		CSharpParser.yIELD_return yIELD614 = null;

		CSharpParser.bREAK_return bREAK615 = null;

		CSharpParser.sEMICOLON_return sEMICOLON616 = null;

		RewriteRuleSubtreeStream stream_expression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule expression");
		RewriteRuleSubtreeStream stream_bREAK =
			new RewriteRuleSubtreeStream(this.adaptor, "rule bREAK");
		RewriteRuleSubtreeStream stream_rETURN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rETURN");
		RewriteRuleSubtreeStream stream_yIELD =
			new RewriteRuleSubtreeStream(this.adaptor, "rule yIELD");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1284:5: ( yIELD rETURN expression sEMICOLON -> ^( YieldStatement yIELD rETURN expression sEMICOLON ) | yIELD bREAK sEMICOLON -> ^( YieldStatement yIELD bREAK sEMICOLON ) )
			int alt115 = 2;
			alt115 = this.dfa115.predict(this.input);
			switch (alt115) {
				case 1 :
				// ../rsc/CSharp.g3:1284:9: yIELD rETURN expression sEMICOLON
					{
						pushFollow(FOLLOW_yIELD_in_yieldstatement8349);
						yIELD610 = yIELD();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_yIELD.add(yIELD610.getTree());
						pushFollow(FOLLOW_rETURN_in_yieldstatement8351);
						rETURN611 = rETURN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rETURN.add(rETURN611.getTree());
						pushFollow(FOLLOW_expression_in_yieldstatement8353);
						expression612 = expression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_expression.add(expression612.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_yieldstatement8355);
						sEMICOLON613 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON613.getTree());

						// AST REWRITE
						// elements: yIELD, rETURN, sEMICOLON, expression
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1285:5: -> ^( YieldStatement yIELD rETURN expression sEMICOLON )
							{
								// ../rsc/CSharp.g3:1285:8: ^( YieldStatement yIELD rETURN expression sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												YieldStatement,
												"YieldStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_yIELD.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rETURN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_expression.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1286:9: yIELD bREAK sEMICOLON
					{
						pushFollow(FOLLOW_yIELD_in_yieldstatement8383);
						yIELD614 = yIELD();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_yIELD.add(yIELD614.getTree());
						pushFollow(FOLLOW_bREAK_in_yieldstatement8385);
						bREAK615 = bREAK();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_bREAK.add(bREAK615.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_yieldstatement8387);
						sEMICOLON616 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON616.getTree());

						// AST REWRITE
						// elements: bREAK, yIELD, sEMICOLON
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1287:5: -> ^( YieldStatement yIELD bREAK sEMICOLON )
							{
								// ../rsc/CSharp.g3:1287:8: ^( YieldStatement yIELD bREAK sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												YieldStatement,
												"YieldStatement"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_yIELD.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_bREAK.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "yieldstatement"

	public static class namespacedeclaration_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "namespacedeclaration"
	// ../rsc/CSharp.g3:1290:1: namespacedeclaration returns [String name] : ( nAMESPACE )=> nAMESPACE qualifiedIdentifier namespacebody ( sEMICOLON )? -> ^( NamespaceDeclaration nAMESPACE qualifiedIdentifier namespacebody ( sEMICOLON )? ) ;
	public final CSharpParser.namespacedeclaration_return namespacedeclaration()
			throws RecognitionException {
		CSharpParser.namespacedeclaration_return retval =
			new CSharpParser.namespacedeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nAMESPACE_return nAMESPACE617 = null;

		CSharpParser.qualifiedIdentifier_return qualifiedIdentifier618 = null;

		CSharpParser.namespacebody_return namespacebody619 = null;

		CSharpParser.sEMICOLON_return sEMICOLON620 = null;

		RewriteRuleSubtreeStream stream_nAMESPACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nAMESPACE");
		RewriteRuleSubtreeStream stream_namespacebody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule namespacebody");
		RewriteRuleSubtreeStream stream_qualifiedIdentifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule qualifiedIdentifier");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1294:5: ( ( nAMESPACE )=> nAMESPACE qualifiedIdentifier namespacebody ( sEMICOLON )? -> ^( NamespaceDeclaration nAMESPACE qualifiedIdentifier namespacebody ( sEMICOLON )? ) )
			// ../rsc/CSharp.g3:1294:9: ( nAMESPACE )=> nAMESPACE qualifiedIdentifier namespacebody ( sEMICOLON )?
			{
				pushFollow(FOLLOW_nAMESPACE_in_namespacedeclaration8442);
				nAMESPACE617 = nAMESPACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_nAMESPACE.add(nAMESPACE617.getTree());
				pushFollow(FOLLOW_qualifiedIdentifier_in_namespacedeclaration8444);
				qualifiedIdentifier618 = qualifiedIdentifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_qualifiedIdentifier.add(qualifiedIdentifier618
						.getTree());
				pushFollow(FOLLOW_namespacebody_in_namespacedeclaration8446);
				namespacebody619 = namespacebody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_namespacebody.add(namespacebody619.getTree());
				// ../rsc/CSharp.g3:1295:50: ( sEMICOLON )?
				int alt116 = 2;
				int LA116_0 = this.input.LA(1);

				if ((LA116_0 == SEMICOLON)) {
					alt116 = 1;
				}
				switch (alt116) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: sEMICOLON
						{
							pushFollow(FOLLOW_sEMICOLON_in_namespacedeclaration8448);
							sEMICOLON620 = sEMICOLON();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_sEMICOLON.add(sEMICOLON620.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {
					retval.name =
						(qualifiedIdentifier618 != null ? qualifiedIdentifier618.name
								: null);
				}

				// AST REWRITE
				// elements: sEMICOLON, namespacebody, qualifiedIdentifier, nAMESPACE
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1297:5: -> ^( NamespaceDeclaration nAMESPACE qualifiedIdentifier namespacebody ( sEMICOLON )? )
					{
						// ../rsc/CSharp.g3:1297:8: ^( NamespaceDeclaration nAMESPACE qualifiedIdentifier namespacebody ( sEMICOLON )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										NamespaceDeclaration,
										"NamespaceDeclaration"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_nAMESPACE.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_qualifiedIdentifier.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_namespacebody.nextTree());
							// ../rsc/CSharp.g3:1297:75: ( sEMICOLON )?
							if (stream_sEMICOLON.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_sEMICOLON.nextTree());

							}
							stream_sEMICOLON.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "namespacedeclaration"

	public static class qualifiedIdentifier_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "qualifiedIdentifier"
	// ../rsc/CSharp.g3:1301:1: qualifiedIdentifier returns [String name] : i1= identifier ( dOT i2= identifier )* -> ^( QualifiedIdentifier identifier ( dOT identifier )* ) ;
	public final CSharpParser.qualifiedIdentifier_return qualifiedIdentifier()
			throws RecognitionException {
		CSharpParser.qualifiedIdentifier_return retval =
			new CSharpParser.qualifiedIdentifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return i1 = null;

		CSharpParser.identifier_return i2 = null;

		CSharpParser.dOT_return dOT621 = null;

		RewriteRuleSubtreeStream stream_dOT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dOT");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:1305:5: (i1= identifier ( dOT i2= identifier )* -> ^( QualifiedIdentifier identifier ( dOT identifier )* ) )
			// ../rsc/CSharp.g3:1305:9: i1= identifier ( dOT i2= identifier )*
			{
				pushFollow(FOLLOW_identifier_in_qualifiedIdentifier8509);
				i1 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(i1.getTree());
				if (this.state.backtracking == 0) {
					sb.append((i1 != null ? i1.content : null));
				}
				// ../rsc/CSharp.g3:1306:6: ( dOT i2= identifier )*
				loop117: do {
					int alt117 = 2;
					int LA117_0 = this.input.LA(1);

					if ((LA117_0 == DOT)) {
						alt117 = 1;
					}

					switch (alt117) {
						case 1 :
						// ../rsc/CSharp.g3:1306:7: dOT i2= identifier
							{
								pushFollow(FOLLOW_dOT_in_qualifiedIdentifier8519);
								dOT621 = dOT();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_dOT.add(dOT621.getTree());
								pushFollow(FOLLOW_identifier_in_qualifiedIdentifier8523);
								i2 = identifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_identifier.add(i2.getTree());
								if (this.state.backtracking == 0) {
									sb.append('.').append(
										(i2 != null ? i2.content : null));
								}

							}
							break;

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

				if (this.state.backtracking == 0) {
					retval.name = sb.toString();
				}

				// AST REWRITE
				// elements: dOT, identifier, identifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1309:5: -> ^( QualifiedIdentifier identifier ( dOT identifier )* )
					{
						// ../rsc/CSharp.g3:1309:8: ^( QualifiedIdentifier identifier ( dOT identifier )* )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										QualifiedIdentifier,
										"QualifiedIdentifier"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:1309:41: ( dOT identifier )*
							while (stream_dOT.hasNext()
									|| stream_identifier.hasNext()) {
								this.adaptor.addChild(root_1, stream_dOT.nextTree());
								this.adaptor.addChild(
									root_1,
									stream_identifier.nextTree());

							}
							stream_dOT.reset();
							stream_identifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "qualifiedIdentifier"

	public static class namespacebody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "namespacebody"
	// ../rsc/CSharp.g3:1312:1: namespacebody : lBRACE ( externaliasdirectives )? ( usingdirectives )? ( namespacememberdeclarations )? rBRACE -> ^( Body lBRACE ( externaliasdirectives )? ( usingdirectives )? ( namespacememberdeclarations )? rBRACE ) ;
	public final CSharpParser.namespacebody_return namespacebody()
			throws RecognitionException {
		CSharpParser.namespacebody_return retval =
			new CSharpParser.namespacebody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACE_return lBRACE622 = null;

		CSharpParser.externaliasdirectives_return externaliasdirectives623 =
			null;

		CSharpParser.usingdirectives_return usingdirectives624 = null;

		CSharpParser.namespacememberdeclarations_return namespacememberdeclarations625 =
			null;

		CSharpParser.rBRACE_return rBRACE626 = null;

		RewriteRuleSubtreeStream stream_externaliasdirectives =
			new RewriteRuleSubtreeStream(this.adaptor, "rule externaliasdirectives");
		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_namespacememberdeclarations =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule namespacememberdeclarations");
		RewriteRuleSubtreeStream stream_usingdirectives =
			new RewriteRuleSubtreeStream(this.adaptor, "rule usingdirectives");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:1313:5: ( lBRACE ( externaliasdirectives )? ( usingdirectives )? ( namespacememberdeclarations )? rBRACE -> ^( Body lBRACE ( externaliasdirectives )? ( usingdirectives )? ( namespacememberdeclarations )? rBRACE ) )
			// ../rsc/CSharp.g3:1313:9: lBRACE ( externaliasdirectives )? ( usingdirectives )? ( namespacememberdeclarations )? rBRACE
			{
				pushFollow(FOLLOW_lBRACE_in_namespacebody8578);
				lBRACE622 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE622.getTree());
				// ../rsc/CSharp.g3:1313:16: ( externaliasdirectives )?
				int alt118 = 2;
				int LA118_0 = this.input.LA(1);

				if ((LA118_0 == EXTERN)) {
					alt118 = 1;
				}
				switch (alt118) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: externaliasdirectives
						{
							pushFollow(FOLLOW_externaliasdirectives_in_namespacebody8580);
							externaliasdirectives623 = externaliasdirectives();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_externaliasdirectives
									.add(externaliasdirectives623.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1313:39: ( usingdirectives )?
				int alt119 = 2;
				int LA119_0 = this.input.LA(1);

				if ((LA119_0 == USING)) {
					alt119 = 1;
				}
				switch (alt119) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: usingdirectives
						{
							pushFollow(FOLLOW_usingdirectives_in_namespacebody8583);
							usingdirectives624 = usingdirectives();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_usingdirectives.add(usingdirectives624
									.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1313:56: ( namespacememberdeclarations )?
				int alt120 = 2;
				int LA120_0 = this.input.LA(1);

				if ((LA120_0 == LBRACKET || LA120_0 == ABSTRACT
						|| LA120_0 == CLASS || LA120_0 == DELEGATE
						|| LA120_0 == ENUM
						|| (LA120_0 >= INTERFACE && LA120_0 <= INTERNAL)
						|| (LA120_0 >= NAMESPACE && LA120_0 <= NEW)
						|| (LA120_0 >= PRIVATE && LA120_0 <= PUBLIC)
						|| LA120_0 == SEALED || LA120_0 == STATIC
						|| LA120_0 == STRUCT || LA120_0 == PARTIAL)) {
					alt120 = 1;
				}
				switch (alt120) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: namespacememberdeclarations
						{
							pushFollow(FOLLOW_namespacememberdeclarations_in_namespacebody8586);
							namespacememberdeclarations625 =
								namespacememberdeclarations();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_namespacememberdeclarations
									.add(namespacememberdeclarations625
										.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rBRACE_in_namespacebody8589);
				rBRACE626 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE626.getTree());

				// AST REWRITE
				// elements: rBRACE, usingdirectives, namespacememberdeclarations, externaliasdirectives, lBRACE
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1314:5: -> ^( Body lBRACE ( externaliasdirectives )? ( usingdirectives )? ( namespacememberdeclarations )? rBRACE )
					{
						// ../rsc/CSharp.g3:1314:8: ^( Body lBRACE ( externaliasdirectives )? ( usingdirectives )? ( namespacememberdeclarations )? rBRACE )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Body, "Body"),
									root_1);

							this.adaptor.addChild(root_1, stream_lBRACE.nextTree());
							// ../rsc/CSharp.g3:1314:22: ( externaliasdirectives )?
							if (stream_externaliasdirectives.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_externaliasdirectives.nextTree());

							}
							stream_externaliasdirectives.reset();
							// ../rsc/CSharp.g3:1314:45: ( usingdirectives )?
							if (stream_usingdirectives.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_usingdirectives.nextTree());

							}
							stream_usingdirectives.reset();
							// ../rsc/CSharp.g3:1314:62: ( namespacememberdeclarations )?
							if (stream_namespacememberdeclarations.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_namespacememberdeclarations
										.nextTree());

							}
							stream_namespacememberdeclarations.reset();
							this.adaptor.addChild(root_1, stream_rBRACE.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "namespacebody"

	public static class externaliasdirectives_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "externaliasdirectives"
	// ../rsc/CSharp.g3:1317:1: externaliasdirectives : ( externaliasdirective )+ -> ^( ExternAliasDirectives ( externaliasdirective )+ ) ;
	public final CSharpParser.externaliasdirectives_return externaliasdirectives()
			throws RecognitionException {
		CSharpParser.externaliasdirectives_return retval =
			new CSharpParser.externaliasdirectives_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.externaliasdirective_return externaliasdirective627 = null;

		RewriteRuleSubtreeStream stream_externaliasdirective =
			new RewriteRuleSubtreeStream(this.adaptor, "rule externaliasdirective");
		try {
			// ../rsc/CSharp.g3:1318:5: ( ( externaliasdirective )+ -> ^( ExternAliasDirectives ( externaliasdirective )+ ) )
			// ../rsc/CSharp.g3:1318:9: ( externaliasdirective )+
			{
				// ../rsc/CSharp.g3:1318:9: ( externaliasdirective )+
				int cnt121 = 0;
				loop121: do {
					int alt121 = 2;
					int LA121_0 = this.input.LA(1);

					if ((LA121_0 == EXTERN)) {
						alt121 = 1;
					}

					switch (alt121) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: externaliasdirective
							{
								pushFollow(FOLLOW_externaliasdirective_in_externaliasdirectives8632);
								externaliasdirective627 =
									externaliasdirective();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_externaliasdirective
										.add(externaliasdirective627.getTree());

							}
							break;

						default :
							if (cnt121 >= 1)
								break loop121;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(121, this.input);
							throw eee;
					}
					cnt121++;
				}
				while (true);

				// AST REWRITE
				// elements: externaliasdirective
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1319:5: -> ^( ExternAliasDirectives ( externaliasdirective )+ )
					{
						// ../rsc/CSharp.g3:1319:8: ^( ExternAliasDirectives ( externaliasdirective )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ExternAliasDirectives,
										"ExternAliasDirectives"), root_1);

							if (!(stream_externaliasdirective.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_externaliasdirective.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_externaliasdirective.nextTree());

							}
							stream_externaliasdirective.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "externaliasdirectives"

	public static class externaliasdirective_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "externaliasdirective"
	// ../rsc/CSharp.g3:1322:1: externaliasdirective : eXTERN aLIAS identifier sEMICOLON ;
	public final CSharpParser.externaliasdirective_return externaliasdirective()
			throws RecognitionException {
		CSharpParser.externaliasdirective_return retval =
			new CSharpParser.externaliasdirective_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.eXTERN_return eXTERN628 = null;

		CSharpParser.aLIAS_return aLIAS629 = null;

		CSharpParser.identifier_return identifier630 = null;

		CSharpParser.sEMICOLON_return sEMICOLON631 = null;

		try {
			// ../rsc/CSharp.g3:1323:5: ( eXTERN aLIAS identifier sEMICOLON )
			// ../rsc/CSharp.g3:1323:9: eXTERN aLIAS identifier sEMICOLON
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_eXTERN_in_externaliasdirective8665);
				eXTERN628 = eXTERN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, eXTERN628.getTree());
				pushFollow(FOLLOW_aLIAS_in_externaliasdirective8667);
				aLIAS629 = aLIAS();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, aLIAS629.getTree());
				pushFollow(FOLLOW_identifier_in_externaliasdirective8669);
				identifier630 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, identifier630.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_externaliasdirective8671);
				sEMICOLON631 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, sEMICOLON631.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "externaliasdirective"

	public static class usingdirectives_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "usingdirectives"
	// ../rsc/CSharp.g3:1326:1: usingdirectives : ( usingdirective )+ -> ^( UsingDirectives ( usingdirective )+ ) ;
	public final CSharpParser.usingdirectives_return usingdirectives()
			throws RecognitionException {
		CSharpParser.usingdirectives_return retval =
			new CSharpParser.usingdirectives_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.usingdirective_return usingdirective632 = null;

		RewriteRuleSubtreeStream stream_usingdirective =
			new RewriteRuleSubtreeStream(this.adaptor, "rule usingdirective");
		try {
			// ../rsc/CSharp.g3:1327:5: ( ( usingdirective )+ -> ^( UsingDirectives ( usingdirective )+ ) )
			// ../rsc/CSharp.g3:1327:9: ( usingdirective )+
			{
				// ../rsc/CSharp.g3:1327:9: ( usingdirective )+
				int cnt122 = 0;
				loop122: do {
					int alt122 = 2;
					int LA122_0 = this.input.LA(1);

					if ((LA122_0 == USING)) {
						alt122 = 1;
					}

					switch (alt122) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: usingdirective
							{
								pushFollow(FOLLOW_usingdirective_in_usingdirectives8691);
								usingdirective632 = usingdirective();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_usingdirective.add(usingdirective632
										.getTree());

							}
							break;

						default :
							if (cnt122 >= 1)
								break loop122;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(122, this.input);
							throw eee;
					}
					cnt122++;
				}
				while (true);

				// AST REWRITE
				// elements: usingdirective
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1328:5: -> ^( UsingDirectives ( usingdirective )+ )
					{
						// ../rsc/CSharp.g3:1328:8: ^( UsingDirectives ( usingdirective )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										UsingDirectives,
										"UsingDirectives"),
									root_1);

							if (!(stream_usingdirective.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_usingdirective.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_usingdirective.nextTree());

							}
							stream_usingdirective.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "usingdirectives"

	public static class usingdirective_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "usingdirective"
	// ../rsc/CSharp.g3:1331:1: usingdirective : ( usingaliasdirective | usingnamespacedirective );
	public final CSharpParser.usingdirective_return usingdirective()
			throws RecognitionException {
		CSharpParser.usingdirective_return retval =
			new CSharpParser.usingdirective_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.usingaliasdirective_return usingaliasdirective633 = null;

		CSharpParser.usingnamespacedirective_return usingnamespacedirective634 =
			null;

		try {
			// ../rsc/CSharp.g3:1332:5: ( usingaliasdirective | usingnamespacedirective )
			int alt123 = 2;
			alt123 = this.dfa123.predict(this.input);
			switch (alt123) {
				case 1 :
				// ../rsc/CSharp.g3:1332:9: usingaliasdirective
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_usingaliasdirective_in_usingdirective8724);
						usingaliasdirective633 = usingaliasdirective();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								usingaliasdirective633.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1333:9: usingnamespacedirective
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_usingnamespacedirective_in_usingdirective8734);
						usingnamespacedirective634 = usingnamespacedirective();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								usingnamespacedirective634.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "usingdirective"

	public static class usingaliasdirective_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "usingaliasdirective"
	// ../rsc/CSharp.g3:1336:1: usingaliasdirective : uSING identifier aSSIGN namespaceortypename sEMICOLON -> ^( UsingAliasDirective uSING identifier aSSIGN namespaceortypename sEMICOLON ) ;
	public final CSharpParser.usingaliasdirective_return usingaliasdirective()
			throws RecognitionException {
		CSharpParser.usingaliasdirective_return retval =
			new CSharpParser.usingaliasdirective_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.uSING_return uSING635 = null;

		CSharpParser.identifier_return identifier636 = null;

		CSharpParser.aSSIGN_return aSSIGN637 = null;

		CSharpParser.namespaceortypename_return namespaceortypename638 = null;

		CSharpParser.sEMICOLON_return sEMICOLON639 = null;

		RewriteRuleSubtreeStream stream_namespaceortypename =
			new RewriteRuleSubtreeStream(this.adaptor, "rule namespaceortypename");
		RewriteRuleSubtreeStream stream_uSING =
			new RewriteRuleSubtreeStream(this.adaptor, "rule uSING");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_aSSIGN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aSSIGN");
		try {
			// ../rsc/CSharp.g3:1337:5: ( uSING identifier aSSIGN namespaceortypename sEMICOLON -> ^( UsingAliasDirective uSING identifier aSSIGN namespaceortypename sEMICOLON ) )
			// ../rsc/CSharp.g3:1337:9: uSING identifier aSSIGN namespaceortypename sEMICOLON
			{
				pushFollow(FOLLOW_uSING_in_usingaliasdirective8753);
				uSING635 = uSING();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_uSING.add(uSING635.getTree());
				pushFollow(FOLLOW_identifier_in_usingaliasdirective8755);
				identifier636 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier636.getTree());
				pushFollow(FOLLOW_aSSIGN_in_usingaliasdirective8757);
				aSSIGN637 = aSSIGN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_aSSIGN.add(aSSIGN637.getTree());
				pushFollow(FOLLOW_namespaceortypename_in_usingaliasdirective8759);
				namespaceortypename638 = namespaceortypename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_namespaceortypename.add(namespaceortypename638
						.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_usingaliasdirective8761);
				sEMICOLON639 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON639.getTree());

				// AST REWRITE
				// elements: aSSIGN, uSING, identifier, sEMICOLON, namespaceortypename
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1338:2: -> ^( UsingAliasDirective uSING identifier aSSIGN namespaceortypename sEMICOLON )
					{
						// ../rsc/CSharp.g3:1338:5: ^( UsingAliasDirective uSING identifier aSSIGN namespaceortypename sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										UsingAliasDirective,
										"UsingAliasDirective"), root_1);

							this.adaptor.addChild(root_1, stream_uSING.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							this.adaptor.addChild(root_1, stream_aSSIGN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_namespaceortypename.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "usingaliasdirective"

	public static class usingnamespacedirective_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "usingnamespacedirective"
	// ../rsc/CSharp.g3:1341:1: usingnamespacedirective : uSING namespacename sEMICOLON -> ^( UsingNamespaceDirective uSING namespacename sEMICOLON ) ;
	public final CSharpParser.usingnamespacedirective_return usingnamespacedirective()
			throws RecognitionException {
		CSharpParser.usingnamespacedirective_return retval =
			new CSharpParser.usingnamespacedirective_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.uSING_return uSING640 = null;

		CSharpParser.namespacename_return namespacename641 = null;

		CSharpParser.sEMICOLON_return sEMICOLON642 = null;

		RewriteRuleSubtreeStream stream_namespacename =
			new RewriteRuleSubtreeStream(this.adaptor, "rule namespacename");
		RewriteRuleSubtreeStream stream_uSING =
			new RewriteRuleSubtreeStream(this.adaptor, "rule uSING");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1342:5: ( uSING namespacename sEMICOLON -> ^( UsingNamespaceDirective uSING namespacename sEMICOLON ) )
			// ../rsc/CSharp.g3:1342:9: uSING namespacename sEMICOLON
			{
				pushFollow(FOLLOW_uSING_in_usingnamespacedirective8797);
				uSING640 = uSING();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_uSING.add(uSING640.getTree());
				pushFollow(FOLLOW_namespacename_in_usingnamespacedirective8799);
				namespacename641 = namespacename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_namespacename.add(namespacename641.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_usingnamespacedirective8801);
				sEMICOLON642 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON642.getTree());

				// AST REWRITE
				// elements: namespacename, sEMICOLON, uSING
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1343:2: -> ^( UsingNamespaceDirective uSING namespacename sEMICOLON )
					{
						// ../rsc/CSharp.g3:1343:5: ^( UsingNamespaceDirective uSING namespacename sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										UsingNamespaceDirective,
										"UsingNamespaceDirective"), root_1);

							this.adaptor.addChild(root_1, stream_uSING.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_namespacename.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "usingnamespacedirective"

	public static class namespacememberdeclarations_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "namespacememberdeclarations"
	// ../rsc/CSharp.g3:1346:1: namespacememberdeclarations : ( namespacememberdeclaration )+ ;
	public final CSharpParser.namespacememberdeclarations_return namespacememberdeclarations()
			throws RecognitionException {
		CSharpParser.namespacememberdeclarations_return retval =
			new CSharpParser.namespacememberdeclarations_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.namespacememberdeclaration_return namespacememberdeclaration643 =
			null;

		try {
			// ../rsc/CSharp.g3:1347:5: ( ( namespacememberdeclaration )+ )
			// ../rsc/CSharp.g3:1347:9: ( namespacememberdeclaration )+
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:1347:9: ( namespacememberdeclaration )+
				int cnt124 = 0;
				loop124: do {
					int alt124 = 2;
					int LA124_0 = this.input.LA(1);

					if ((LA124_0 == LBRACKET || LA124_0 == ABSTRACT
							|| LA124_0 == CLASS || LA124_0 == DELEGATE
							|| LA124_0 == ENUM
							|| (LA124_0 >= INTERFACE && LA124_0 <= INTERNAL)
							|| (LA124_0 >= NAMESPACE && LA124_0 <= NEW)
							|| (LA124_0 >= PRIVATE && LA124_0 <= PUBLIC)
							|| LA124_0 == SEALED || LA124_0 == STATIC
							|| LA124_0 == STRUCT || LA124_0 == PARTIAL)) {
						alt124 = 1;
					}

					switch (alt124) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: namespacememberdeclaration
							{
								pushFollow(FOLLOW_namespacememberdeclaration_in_namespacememberdeclarations8834);
								namespacememberdeclaration643 =
									namespacememberdeclaration();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor
										.addChild(
											root_0,
											namespacememberdeclaration643
												.getTree());

							}
							break;

						default :
							if (cnt124 >= 1)
								break loop124;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(124, this.input);
							throw eee;
					}
					cnt124++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "namespacememberdeclarations"

	public static class namespacememberdeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "namespacememberdeclaration"
	// ../rsc/CSharp.g3:1350:1: namespacememberdeclaration : ( namespacedeclaration | typedeclaration );
	public final CSharpParser.namespacememberdeclaration_return namespacememberdeclaration()
			throws RecognitionException {
		CSharpParser.namespacememberdeclaration_return retval =
			new CSharpParser.namespacememberdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.namespacedeclaration_return namespacedeclaration644 = null;

		CSharpParser.typedeclaration_return typedeclaration645 = null;

		try {
			// ../rsc/CSharp.g3:1351:5: ( namespacedeclaration | typedeclaration )
			int alt125 = 2;
			int LA125_0 = this.input.LA(1);

			if ((LA125_0 == NAMESPACE)) {
				alt125 = 1;
			}
			else if ((LA125_0 == LBRACKET || LA125_0 == ABSTRACT
					|| LA125_0 == CLASS || LA125_0 == DELEGATE
					|| LA125_0 == ENUM
					|| (LA125_0 >= INTERFACE && LA125_0 <= INTERNAL)
					|| LA125_0 == NEW
					|| (LA125_0 >= PRIVATE && LA125_0 <= PUBLIC)
					|| LA125_0 == SEALED || LA125_0 == STATIC
					|| LA125_0 == STRUCT || LA125_0 == PARTIAL)) {
				alt125 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 125, 0, this.input);

				throw nvae;
			}
			switch (alt125) {
				case 1 :
				// ../rsc/CSharp.g3:1351:9: namespacedeclaration
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_namespacedeclaration_in_namespacememberdeclaration8854);
						namespacedeclaration644 = namespacedeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								namespacedeclaration644.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1352:9: typedeclaration
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_typedeclaration_in_namespacememberdeclaration8864);
						typedeclaration645 = typedeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								typedeclaration645.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "namespacememberdeclaration"

	public static class typedeclaration_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typedeclaration"
	// ../rsc/CSharp.g3:1357:1: typedeclaration : ( ( ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS )=> classdeclaration -> ^( TypeDeclaration classdeclaration ) | ( ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT )=> structdeclaration -> ^( TypeDeclaration structdeclaration ) | ( ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE )=> interfacedeclaration -> ^( TypeDeclaration interfacedeclaration ) | ( ( attributes )? ( enummodifiers )? eNUM )=> enumdeclaration -> ^( TypeDeclaration enumdeclaration ) | ( ( attributes )? ( delegatemodifiers )? dELEGATE )=> delegatedeclaration -> ^( TypeDeclaration delegatedeclaration ) );
	public final CSharpParser.typedeclaration_return typedeclaration()
			throws RecognitionException {
		CSharpParser.typedeclaration_return retval =
			new CSharpParser.typedeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.classdeclaration_return classdeclaration646 = null;

		CSharpParser.structdeclaration_return structdeclaration647 = null;

		CSharpParser.interfacedeclaration_return interfacedeclaration648 = null;

		CSharpParser.enumdeclaration_return enumdeclaration649 = null;

		CSharpParser.delegatedeclaration_return delegatedeclaration650 = null;

		RewriteRuleSubtreeStream stream_enumdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule enumdeclaration");
		RewriteRuleSubtreeStream stream_interfacedeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfacedeclaration");
		RewriteRuleSubtreeStream stream_structdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule structdeclaration");
		RewriteRuleSubtreeStream stream_delegatedeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule delegatedeclaration");
		RewriteRuleSubtreeStream stream_classdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classdeclaration");
		try {
			// ../rsc/CSharp.g3:1358:5: ( ( ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS )=> classdeclaration -> ^( TypeDeclaration classdeclaration ) | ( ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT )=> structdeclaration -> ^( TypeDeclaration structdeclaration ) | ( ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE )=> interfacedeclaration -> ^( TypeDeclaration interfacedeclaration ) | ( ( attributes )? ( enummodifiers )? eNUM )=> enumdeclaration -> ^( TypeDeclaration enumdeclaration ) | ( ( attributes )? ( delegatemodifiers )? dELEGATE )=> delegatedeclaration -> ^( TypeDeclaration delegatedeclaration ) )
			int alt126 = 5;
			alt126 = this.dfa126.predict(this.input);
			switch (alt126) {
				case 1 :
				// ../rsc/CSharp.g3:1358:9: ( ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS )=> classdeclaration
					{
						pushFollow(FOLLOW_classdeclaration_in_typedeclaration8900);
						classdeclaration646 = classdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_classdeclaration.add(classdeclaration646
								.getTree());

						// AST REWRITE
						// elements: classdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1359:5: -> ^( TypeDeclaration classdeclaration )
							{
								// ../rsc/CSharp.g3:1359:8: ^( TypeDeclaration classdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeDeclaration,
												"TypeDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_classdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1360:9: ( ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT )=> structdeclaration
					{
						pushFollow(FOLLOW_structdeclaration_in_typedeclaration8937);
						structdeclaration647 = structdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_structdeclaration.add(structdeclaration647
								.getTree());

						// AST REWRITE
						// elements: structdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1361:5: -> ^( TypeDeclaration structdeclaration )
							{
								// ../rsc/CSharp.g3:1361:8: ^( TypeDeclaration structdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeDeclaration,
												"TypeDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_structdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1362:9: ( ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE )=> interfacedeclaration
					{
						pushFollow(FOLLOW_interfacedeclaration_in_typedeclaration8974);
						interfacedeclaration648 = interfacedeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_interfacedeclaration
								.add(interfacedeclaration648.getTree());

						// AST REWRITE
						// elements: interfacedeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1363:5: -> ^( TypeDeclaration interfacedeclaration )
							{
								// ../rsc/CSharp.g3:1363:8: ^( TypeDeclaration interfacedeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeDeclaration,
												"TypeDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_interfacedeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1364:9: ( ( attributes )? ( enummodifiers )? eNUM )=> enumdeclaration
					{
						pushFollow(FOLLOW_enumdeclaration_in_typedeclaration9008);
						enumdeclaration649 = enumdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_enumdeclaration.add(enumdeclaration649
								.getTree());

						// AST REWRITE
						// elements: enumdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1365:5: -> ^( TypeDeclaration enumdeclaration )
							{
								// ../rsc/CSharp.g3:1365:8: ^( TypeDeclaration enumdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeDeclaration,
												"TypeDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_enumdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1366:9: ( ( attributes )? ( delegatemodifiers )? dELEGATE )=> delegatedeclaration
					{
						pushFollow(FOLLOW_delegatedeclaration_in_typedeclaration9042);
						delegatedeclaration650 = delegatedeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_delegatedeclaration
								.add(delegatedeclaration650.getTree());

						// AST REWRITE
						// elements: delegatedeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1367:5: -> ^( TypeDeclaration delegatedeclaration )
							{
								// ../rsc/CSharp.g3:1367:8: ^( TypeDeclaration delegatedeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeDeclaration,
												"TypeDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_delegatedeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typedeclaration"

	public static class qualifiedaliasmember_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "qualifiedaliasmember"
	// ../rsc/CSharp.g3:1370:1: qualifiedaliasmember returns [String name] : i1= identifier dOUBLECOLON i2= identifier ( typeargumentlist )? -> ^( QualifiedAliasMember identifier dOUBLECOLON identifier ( typeargumentlist )? ) ;
	public final CSharpParser.qualifiedaliasmember_return qualifiedaliasmember()
			throws RecognitionException {
		CSharpParser.qualifiedaliasmember_return retval =
			new CSharpParser.qualifiedaliasmember_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return i1 = null;

		CSharpParser.identifier_return i2 = null;

		CSharpParser.dOUBLECOLON_return dOUBLECOLON651 = null;

		CSharpParser.typeargumentlist_return typeargumentlist652 = null;

		RewriteRuleSubtreeStream stream_dOUBLECOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dOUBLECOLON");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_typeargumentlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeargumentlist");
		try {
			// ../rsc/CSharp.g3:1371:5: (i1= identifier dOUBLECOLON i2= identifier ( typeargumentlist )? -> ^( QualifiedAliasMember identifier dOUBLECOLON identifier ( typeargumentlist )? ) )
			// ../rsc/CSharp.g3:1371:9: i1= identifier dOUBLECOLON i2= identifier ( typeargumentlist )?
			{
				pushFollow(FOLLOW_identifier_in_qualifiedaliasmember9079);
				i1 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(i1.getTree());
				pushFollow(FOLLOW_dOUBLECOLON_in_qualifiedaliasmember9081);
				dOUBLECOLON651 = dOUBLECOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_dOUBLECOLON.add(dOUBLECOLON651.getTree());
				pushFollow(FOLLOW_identifier_in_qualifiedaliasmember9085);
				i2 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(i2.getTree());
				// ../rsc/CSharp.g3:1371:49: ( typeargumentlist )?
				int alt127 = 2;
				alt127 = this.dfa127.predict(this.input);
				switch (alt127) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeargumentlist
						{
							pushFollow(FOLLOW_typeargumentlist_in_qualifiedaliasmember9087);
							typeargumentlist652 = typeargumentlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeargumentlist.add(typeargumentlist652
									.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {
					retval.name =
						(i1 != null ? i1.content : null) + "::"
								+ (i2 != null ? i2.content : null);
				}

				// AST REWRITE
				// elements: typeargumentlist, identifier, identifier, dOUBLECOLON
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1373:5: -> ^( QualifiedAliasMember identifier dOUBLECOLON identifier ( typeargumentlist )? )
					{
						// ../rsc/CSharp.g3:1373:8: ^( QualifiedAliasMember identifier dOUBLECOLON identifier ( typeargumentlist )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										QualifiedAliasMember,
										"QualifiedAliasMember"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_dOUBLECOLON.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:1373:65: ( typeargumentlist )?
							if (stream_typeargumentlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeargumentlist.nextTree());

							}
							stream_typeargumentlist.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "qualifiedaliasmember"

	public static class classdeclaration_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "classdeclaration"
	// ../rsc/CSharp.g3:1377:1: classdeclaration returns [String name] : ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS identifier ( typeparameterlist )? ( classbase )? ( typeparameterconstraintsclauses )? classbody ( sEMICOLON )? -> ^( Class ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS identifier ( typeparameterlist )? ( classbase )? ( typeparameterconstraintsclauses )? classbody ( sEMICOLON )? ) ;
	public final CSharpParser.classdeclaration_return classdeclaration()
			throws RecognitionException {
		CSharpParser.classdeclaration_return retval =
			new CSharpParser.classdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes653 = null;

		CSharpParser.classmodifiers_return classmodifiers654 = null;

		CSharpParser.pARTIAL_return pARTIAL655 = null;

		CSharpParser.cLASS_return cLASS656 = null;

		CSharpParser.identifier_return identifier657 = null;

		CSharpParser.typeparameterlist_return typeparameterlist658 = null;

		CSharpParser.classbase_return classbase659 = null;

		CSharpParser.typeparameterconstraintsclauses_return typeparameterconstraintsclauses660 =
			null;

		CSharpParser.classbody_return classbody661 = null;

		CSharpParser.sEMICOLON_return sEMICOLON662 = null;

		RewriteRuleSubtreeStream stream_pARTIAL =
			new RewriteRuleSubtreeStream(this.adaptor, "rule pARTIAL");
		RewriteRuleSubtreeStream stream_typeparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameterlist");
		RewriteRuleSubtreeStream stream_typeparameterconstraintsclauses =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule typeparameterconstraintsclauses");
		RewriteRuleSubtreeStream stream_classmodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classmodifiers");
		RewriteRuleSubtreeStream stream_classbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classbody");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_classbase =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classbase");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_cLASS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cLASS");
		try {
			// ../rsc/CSharp.g3:1445:5: ( ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS identifier ( typeparameterlist )? ( classbase )? ( typeparameterconstraintsclauses )? classbody ( sEMICOLON )? -> ^( Class ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS identifier ( typeparameterlist )? ( classbase )? ( typeparameterconstraintsclauses )? classbody ( sEMICOLON )? ) )
			// ../rsc/CSharp.g3:1445:9: ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS identifier ( typeparameterlist )? ( classbase )? ( typeparameterconstraintsclauses )? classbody ( sEMICOLON )?
			{
				// ../rsc/CSharp.g3:1445:9: ( attributes )?
				int alt128 = 2;
				int LA128_0 = this.input.LA(1);

				if ((LA128_0 == LBRACKET)) {
					alt128 = 1;
				}
				switch (alt128) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_classdeclaration9143);
							attributes653 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes653.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1445:21: ( classmodifiers )?
				int alt129 = 2;
				int LA129_0 = this.input.LA(1);

				if ((LA129_0 == ABSTRACT || LA129_0 == INTERNAL
						|| LA129_0 == NEW
						|| (LA129_0 >= PRIVATE && LA129_0 <= PUBLIC)
						|| LA129_0 == SEALED || LA129_0 == STATIC)) {
					alt129 = 1;
				}
				switch (alt129) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: classmodifiers
						{
							pushFollow(FOLLOW_classmodifiers_in_classdeclaration9146);
							classmodifiers654 = classmodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_classmodifiers.add(classmodifiers654
									.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1445:37: ( pARTIAL )?
				int alt130 = 2;
				int LA130_0 = this.input.LA(1);

				if ((LA130_0 == PARTIAL)) {
					alt130 = 1;
				}
				switch (alt130) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: pARTIAL
						{
							pushFollow(FOLLOW_pARTIAL_in_classdeclaration9149);
							pARTIAL655 = pARTIAL();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_pARTIAL.add(pARTIAL655.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_cLASS_in_classdeclaration9152);
				cLASS656 = cLASS();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cLASS.add(cLASS656.getTree());
				pushFollow(FOLLOW_identifier_in_classdeclaration9154);
				identifier657 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier657.getTree());
				// ../rsc/CSharp.g3:1445:63: ( typeparameterlist )?
				int alt131 = 2;
				int LA131_0 = this.input.LA(1);

				if ((LA131_0 == LT)) {
					alt131 = 1;
				}
				switch (alt131) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterlist
						{
							pushFollow(FOLLOW_typeparameterlist_in_classdeclaration9156);
							typeparameterlist658 = typeparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterlist
									.add(typeparameterlist658.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1446:7: ( classbase )?
				int alt132 = 2;
				int LA132_0 = this.input.LA(1);

				if ((LA132_0 == COLON)) {
					alt132 = 1;
				}
				switch (alt132) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: classbase
						{
							pushFollow(FOLLOW_classbase_in_classdeclaration9165);
							classbase659 = classbase();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_classbase.add(classbase659.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1446:18: ( typeparameterconstraintsclauses )?
				int alt133 = 2;
				int LA133_0 = this.input.LA(1);

				if ((LA133_0 == WHERE)) {
					alt133 = 1;
				}
				switch (alt133) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterconstraintsclauses
						{
							pushFollow(FOLLOW_typeparameterconstraintsclauses_in_classdeclaration9168);
							typeparameterconstraintsclauses660 =
								typeparameterconstraintsclauses();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterconstraintsclauses
									.add(typeparameterconstraintsclauses660
										.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_classbody_in_classdeclaration9171);
				classbody661 = classbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_classbody.add(classbody661.getTree());
				// ../rsc/CSharp.g3:1446:61: ( sEMICOLON )?
				int alt134 = 2;
				int LA134_0 = this.input.LA(1);

				if ((LA134_0 == SEMICOLON)) {
					alt134 = 1;
				}
				switch (alt134) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: sEMICOLON
						{
							pushFollow(FOLLOW_sEMICOLON_in_classdeclaration9173);
							sEMICOLON662 = sEMICOLON();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_sEMICOLON.add(sEMICOLON662.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {

					retval.name =
						(identifier657 != null ? identifier657.content : null);
					//	$body = $classbody.content;

				}

				// AST REWRITE
				// elements: classmodifiers, classbody, attributes, sEMICOLON, typeparameterconstraintsclauses, pARTIAL, typeparameterlist, cLASS, classbase, identifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1451:5: -> ^( Class ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS identifier ( typeparameterlist )? ( classbase )? ( typeparameterconstraintsclauses )? classbody ( sEMICOLON )? )
					{
						// ../rsc/CSharp.g3:1451:8: ^( Class ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS identifier ( typeparameterlist )? ( classbase )? ( typeparameterconstraintsclauses )? classbody ( sEMICOLON )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Class, "Class"),
									root_1);

							// ../rsc/CSharp.g3:1451:16: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:1451:28: ( classmodifiers )?
							if (stream_classmodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_classmodifiers.nextTree());

							}
							stream_classmodifiers.reset();
							// ../rsc/CSharp.g3:1451:44: ( pARTIAL )?
							if (stream_pARTIAL.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_pARTIAL.nextTree());

							}
							stream_pARTIAL.reset();
							this.adaptor.addChild(root_1, stream_cLASS.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:1451:70: ( typeparameterlist )?
							if (stream_typeparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterlist.nextTree());

							}
							stream_typeparameterlist.reset();
							// ../rsc/CSharp.g3:1452:7: ( classbase )?
							if (stream_classbase.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_classbase.nextTree());

							}
							stream_classbase.reset();
							// ../rsc/CSharp.g3:1452:18: ( typeparameterconstraintsclauses )?
							if (stream_typeparameterconstraintsclauses
								.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterconstraintsclauses
										.nextTree());

							}
							stream_typeparameterconstraintsclauses.reset();
							this.adaptor.addChild(
								root_1,
								stream_classbody.nextTree());
							// ../rsc/CSharp.g3:1452:61: ( sEMICOLON )?
							if (stream_sEMICOLON.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_sEMICOLON.nextTree());

							}
							stream_sEMICOLON.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {
				this.tokenNameMap.put(((Object) retval.tree), retval.name);
				//	System.out.println(((Object)retval.tree));
				//	System.out.println(retval.name);

					final IClass entity =
						this.getFactory().createClass(
							retval.name.toCharArray(),
							retval.name.toCharArray());
					codeLevelModel.addConstituent(entity);
					//	classStockBody.add(element1);
					// TODO Why increment here?
					// this.ElementclassNumber = this.ElementclassNumber + 1;
					// body devra etre une liste entity.addConstituent($body);
					for (int i = 0; i < this.ElementclassNumber; i++) {
						try {
						((IClass) entity)
							.addConstituent((IConstituentOfEntity) this.classStockBody
								.get(i));
						}
						catch(ModelDeclarationException e){
							e.printStackTrace(ProxyConsole.getInstance().errorOutput());
						}
					}

					if (this.Classmodifier == Modifier.PUBLIC) {
						entity.setPublic(true);
						//System.out.println("voila yousra");
					}
					else if (this.Classmodifier == Modifier.PRIVATE) {
						entity.setPrivate(true);
						//System.out.println("voila yousra");

					}
					if (this.Classmodifier == Modifier.PROTECTED) {
						entity.setProtected(true);
						//System.out.println("voila yousra");

					}
					if (this.Classmodifier == Modifier.STATIC) {
						entity.setStatic(true);
						//System.out.println("voila yousra");

					}
					if (this.Classmodifier == Modifier.ABSTRACT) {
						entity.setAbstract(true);
						//System.out.println("voila yousra");

					}
					if (this.Classmodifier == Modifier.ABSTRACT + Modifier.PUBLIC) {
						entity.setAbstract(true);
						//System.out.println("voila yousra");

					}

					//System.out.print(Modifier.toString(this.Classmodifier) + " ");

					//System.out.println(((Object)retval.tree));
					//System.out.println("class " + retval.name);

					// body devra etre une liste entity.addConstituent($body);
					//System.out.println("le nombre de constituent de la class est " + entity.getNumberOfConstituents());

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "classdeclaration"

	public static class classmodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "classmodifiers"
	// ../rsc/CSharp.g3:1456:1: classmodifiers : ( classmodifier )+ -> ^( Modifiers ( classmodifier )+ ) ;
	public final CSharpParser.classmodifiers_return classmodifiers()
			throws RecognitionException {
		CSharpParser.classmodifiers_return retval =
			new CSharpParser.classmodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.classmodifier_return classmodifier663 = null;

		RewriteRuleSubtreeStream stream_classmodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classmodifier");
		try {
			// ../rsc/CSharp.g3:1460:5: ( ( classmodifier )+ -> ^( Modifiers ( classmodifier )+ ) )
			// ../rsc/CSharp.g3:1460:9: ( classmodifier )+
			{
				// ../rsc/CSharp.g3:1460:9: ( classmodifier )+
				int cnt135 = 0;
				loop135: do {
					int alt135 = 2;
					int LA135_0 = this.input.LA(1);

					if ((LA135_0 == ABSTRACT || LA135_0 == INTERNAL
							|| LA135_0 == NEW
							|| (LA135_0 >= PRIVATE && LA135_0 <= PUBLIC)
							|| LA135_0 == SEALED || LA135_0 == STATIC)) {
						alt135 = 1;
					}

					switch (alt135) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: classmodifier
							{
								pushFollow(FOLLOW_classmodifier_in_classmodifiers9249);
								classmodifier663 = classmodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_classmodifier.add(classmodifier663
										.getTree());

							}
							break;

						default :
							if (cnt135 >= 1)
								break loop135;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(135, this.input);
							throw eee;
					}
					cnt135++;
				}
				while (true);

				// AST REWRITE
				// elements: classmodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1461:5: -> ^( Modifiers ( classmodifier )+ )
					{
						// ../rsc/CSharp.g3:1461:9: ^( Modifiers ( classmodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_classmodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_classmodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_classmodifier.nextTree());

							}
							stream_classmodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "classmodifiers"

	public static class classmodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "classmodifier"
	// ../rsc/CSharp.g3:1464:1: classmodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | aBSTRACT | sEALED | sTATIC );
	public final CSharpParser.classmodifier_return classmodifier()
			throws RecognitionException {
		CSharpParser.classmodifier_return retval =
			new CSharpParser.classmodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW664 = null;

		CSharpParser.pUBLIC_return pUBLIC665 = null;

		CSharpParser.pROTECTED_return pROTECTED666 = null;

		CSharpParser.iNTERNAL_return iNTERNAL667 = null;

		CSharpParser.pRIVATE_return pRIVATE668 = null;

		CSharpParser.aBSTRACT_return aBSTRACT669 = null;

		CSharpParser.sEALED_return sEALED670 = null;

		CSharpParser.sTATIC_return sTATIC671 = null;

		try {
			// ../rsc/CSharp.g3:1465:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | aBSTRACT | sEALED | sTATIC )
			int alt136 = 8;
			switch (this.input.LA(1)) {
				case NEW :
					{
						alt136 = 1;
					}
					break;
				case PUBLIC :
					{
						alt136 = 2;
					}
					break;
				case PROTECTED :
					{
						alt136 = 3;
					}
					break;
				case INTERNAL :
					{
						alt136 = 4;
					}
					break;
				case PRIVATE :
					{
						alt136 = 5;
					}
					break;
				case ABSTRACT :
					{
						alt136 = 6;
					}
					break;
				case SEALED :
					{
						alt136 = 7;
					}
					break;
				case STATIC :
					{
						alt136 = 8;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 136, 0, this.input);

					throw nvae;
			}

			switch (alt136) {
				case 1 :
				// ../rsc/CSharp.g3:1465:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_classmodifier9283);
						nEW664 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW664.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(nEW664.getTree());
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1467:9: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_classmodifier9298);
						pUBLIC665 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC665.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1468:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_classmodifier9308);
						pROTECTED666 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED666.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1469:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_classmodifier9318);
						iNTERNAL667 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL667.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1470:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_classmodifier9328);
						pRIVATE668 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE668.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:1471:9: aBSTRACT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aBSTRACT_in_classmodifier9338);
						aBSTRACT669 = aBSTRACT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aBSTRACT669.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:1472:9: sEALED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEALED_in_classmodifier9348);
						sEALED670 = sEALED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEALED670.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:1473:9: sTATIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTATIC_in_classmodifier9358);
						sTATIC671 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTATIC671.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "classmodifier"

	public static class classbase_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "classbase"
	// ../rsc/CSharp.g3:1476:1: classbase : ( cOLON classtype cOMMA interfacetypelist -> ^( ClassBase cOLON classtype cOMMA interfacetypelist ) | cOLON classtype -> ^( ClassBase cOLON classtype ) );
	public final CSharpParser.classbase_return classbase()
			throws RecognitionException {
		CSharpParser.classbase_return retval =
			new CSharpParser.classbase_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cOLON_return cOLON672 = null;

		CSharpParser.classtype_return classtype673 = null;

		CSharpParser.cOMMA_return cOMMA674 = null;

		CSharpParser.interfacetypelist_return interfacetypelist675 = null;

		CSharpParser.cOLON_return cOLON676 = null;

		CSharpParser.classtype_return classtype677 = null;

		RewriteRuleSubtreeStream stream_cOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOLON");
		RewriteRuleSubtreeStream stream_interfacetypelist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfacetypelist");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		RewriteRuleSubtreeStream stream_classtype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classtype");
		try {
			// ../rsc/CSharp.g3:1477:5: ( cOLON classtype cOMMA interfacetypelist -> ^( ClassBase cOLON classtype cOMMA interfacetypelist ) | cOLON classtype -> ^( ClassBase cOLON classtype ) )
			int alt137 = 2;
			int LA137_0 = this.input.LA(1);

			if ((LA137_0 == COLON)) {
				this.input.LA(2);

				if ((synpred349_CSharp())) {
					alt137 = 1;
				}
				else if ((true)) {
					alt137 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 137, 0, this.input);

				throw nvae;
			}
			switch (alt137) {
				case 1 :
				// ../rsc/CSharp.g3:1477:7: cOLON classtype cOMMA interfacetypelist
					{
						pushFollow(FOLLOW_cOLON_in_classbase9375);
						cOLON672 = cOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOLON.add(cOLON672.getTree());
						pushFollow(FOLLOW_classtype_in_classbase9377);
						classtype673 = classtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_classtype.add(classtype673.getTree());
						pushFollow(FOLLOW_cOMMA_in_classbase9379);
						cOMMA674 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA674.getTree());
						pushFollow(FOLLOW_interfacetypelist_in_classbase9381);
						interfacetypelist675 = interfacetypelist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_interfacetypelist.add(interfacetypelist675
								.getTree());

						// AST REWRITE
						// elements: classtype, cOLON, interfacetypelist, cOMMA
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1478:5: -> ^( ClassBase cOLON classtype cOMMA interfacetypelist )
							{
								// ../rsc/CSharp.g3:1478:9: ^( ClassBase cOLON classtype cOMMA interfacetypelist )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassBase,
												"ClassBase"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_cOLON.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_classtype.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_interfacetypelist.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1483:9: cOLON classtype
					{
						pushFollow(FOLLOW_cOLON_in_classbase9414);
						cOLON676 = cOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOLON.add(cOLON676.getTree());
						pushFollow(FOLLOW_classtype_in_classbase9416);
						classtype677 = classtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_classtype.add(classtype677.getTree());

						// AST REWRITE
						// elements: cOLON, classtype
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1484:5: -> ^( ClassBase cOLON classtype )
							{
								// ../rsc/CSharp.g3:1484:9: ^( ClassBase cOLON classtype )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassBase,
												"ClassBase"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_cOLON.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_classtype.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "classbase"

	public static class interfacetypelist_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacetypelist"
	// ../rsc/CSharp.g3:1487:1: interfacetypelist : interfacetype ( cOMMA interfacetype )* ;
	public final CSharpParser.interfacetypelist_return interfacetypelist()
			throws RecognitionException {
		CSharpParser.interfacetypelist_return retval =
			new CSharpParser.interfacetypelist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.interfacetype_return interfacetype678 = null;

		CSharpParser.cOMMA_return cOMMA679 = null;

		CSharpParser.interfacetype_return interfacetype680 = null;

		try {
			// ../rsc/CSharp.g3:1488:5: ( interfacetype ( cOMMA interfacetype )* )
			// ../rsc/CSharp.g3:1488:9: interfacetype ( cOMMA interfacetype )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_interfacetype_in_interfacetypelist9451);
				interfacetype678 = interfacetype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, interfacetype678.getTree());
				// ../rsc/CSharp.g3:1488:23: ( cOMMA interfacetype )*
				loop138: do {
					int alt138 = 2;
					int LA138_0 = this.input.LA(1);

					if ((LA138_0 == COMMA)) {
						alt138 = 1;
					}

					switch (alt138) {
						case 1 :
						// ../rsc/CSharp.g3:1488:24: cOMMA interfacetype
							{
								pushFollow(FOLLOW_cOMMA_in_interfacetypelist9454);
								cOMMA679 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor
										.addChild(root_0, cOMMA679.getTree());
								pushFollow(FOLLOW_interfacetype_in_interfacetypelist9456);
								interfacetype680 = interfacetype();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										interfacetype680.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacetypelist"

	public static class classbody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "classbody"
	// ../rsc/CSharp.g3:1491:1: classbody : lBRACE ( classmemberdeclaration )* rBRACE -> ^( Body lBRACE ( classmemberdeclaration )* rBRACE ) ;
	public final CSharpParser.classbody_return classbody()
			throws RecognitionException {
		CSharpParser.classbody_return retval =
			new CSharpParser.classbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACE_return lBRACE681 = null;

		CSharpParser.classmemberdeclaration_return classmemberdeclaration682 =
			null;

		CSharpParser.rBRACE_return rBRACE683 = null;

		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_classmemberdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classmemberdeclaration");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:1492:5: ( lBRACE ( classmemberdeclaration )* rBRACE -> ^( Body lBRACE ( classmemberdeclaration )* rBRACE ) )
			// ../rsc/CSharp.g3:1492:9: lBRACE ( classmemberdeclaration )* rBRACE
			{
				pushFollow(FOLLOW_lBRACE_in_classbody9477);
				lBRACE681 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE681.getTree());
				// ../rsc/CSharp.g3:1492:16: ( classmemberdeclaration )*
				loop139: do {
					int alt139 = 2;
					int LA139_0 = this.input.LA(1);

					if ((LA139_0 == LBRACKET || LA139_0 == TILDE
							|| LA139_0 == ABSTRACT || LA139_0 == BOOL
							|| LA139_0 == BYTE || LA139_0 == CHAR
							|| (LA139_0 >= CLASS && LA139_0 <= CONST)
							|| LA139_0 == DECIMAL || LA139_0 == DELEGATE
							|| LA139_0 == DOUBLE
							|| (LA139_0 >= ENUM && LA139_0 <= EVENT)
							|| LA139_0 == EXTERN || LA139_0 == FLOAT
							|| (LA139_0 >= INT && LA139_0 <= INTERNAL)
							|| LA139_0 == LONG || LA139_0 == NEW
							|| LA139_0 == OBJECT || LA139_0 == OVERRIDE
							|| (LA139_0 >= PRIVATE && LA139_0 <= READONLY)
							|| (LA139_0 >= SBYTE && LA139_0 <= SHORT)
							|| (LA139_0 >= STATIC && LA139_0 <= STRUCT)
							|| (LA139_0 >= UINT && LA139_0 <= ULONG)
							|| LA139_0 == USHORT
							|| (LA139_0 >= VIRTUAL && LA139_0 <= VOLATILE) || (LA139_0 >= ADD && LA139_0 <= Ident))) {
						alt139 = 1;
					}

					switch (alt139) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: classmemberdeclaration
							{
								pushFollow(FOLLOW_classmemberdeclaration_in_classbody9479);
								classmemberdeclaration682 =
									classmemberdeclaration();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_classmemberdeclaration
										.add(classmemberdeclaration682
											.getTree());

							}
							break;

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

				pushFollow(FOLLOW_rBRACE_in_classbody9482);
				rBRACE683 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE683.getTree());

				// AST REWRITE
				// elements: classmemberdeclaration, rBRACE, lBRACE
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1493:5: -> ^( Body lBRACE ( classmemberdeclaration )* rBRACE )
					{
						// ../rsc/CSharp.g3:1493:8: ^( Body lBRACE ( classmemberdeclaration )* rBRACE )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Body, "Body"),
									root_1);

							this.adaptor.addChild(root_1, stream_lBRACE.nextTree());
							// ../rsc/CSharp.g3:1493:22: ( classmemberdeclaration )*
							while (stream_classmemberdeclaration.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_classmemberdeclaration.nextTree());

							}
							stream_classmemberdeclaration.reset();
							this.adaptor.addChild(root_1, stream_rBRACE.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "classbody"

	public static class classmemberdeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "classmemberdeclaration"
	// ../rsc/CSharp.g3:1501:1: classmemberdeclaration : ( ( ( attributes )? ( constantmodifiers )? cONST )=> constantdeclaration -> ^( ClassMemberDeclaration constantdeclaration ) | fielddeclaration -> ^( ClassMemberDeclaration fielddeclaration ) | ( methodheader )=> methoddeclaration -> ^( ClassMemberDeclaration methoddeclaration ) | propertydeclaration -> ^( ClassMemberDeclaration propertydeclaration ) | ( ( attributes )? ( eventmodifiers )? eVENT )=> eventdeclaration -> ^( ClassMemberDeclaration eventdeclaration ) | ( ( attributes )? ( indexermodifiers )? indexerdeclarator )=> indexerdeclaration -> ^( ClassMemberDeclaration indexerdeclaration ) | ( ( attributes )? operatormodifiers operatordeclarator )=> operatordeclaration -> ^( ClassMemberDeclaration operatordeclaration ) | ( ( attributes )? ( constructormodifiers )? constructordeclarator )=> constructordeclaration -> ^( ClassMemberDeclaration constructordeclaration ) | ( ( attributes )? ( eXTERN )? tILDE )=> finalizerdeclaration -> ^( ClassMemberDeclaration finalizerdeclaration ) | ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )=> staticconstructordeclaration -> ^( ClassMemberDeclaration staticconstructordeclaration ) | typedeclaration -> ^( ClassMemberDeclaration typedeclaration ) );
	public final CSharpParser.classmemberdeclaration_return classmemberdeclaration()
			throws RecognitionException {
		CSharpParser.classmemberdeclaration_return retval =
			new CSharpParser.classmemberdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.constantdeclaration_return constantdeclaration684 = null;

		CSharpParser.fielddeclaration_return fielddeclaration685 = null;

		CSharpParser.methoddeclaration_return methoddeclaration686 = null;

		CSharpParser.propertydeclaration_return propertydeclaration687 = null;

		CSharpParser.eventdeclaration_return eventdeclaration688 = null;

		CSharpParser.indexerdeclaration_return indexerdeclaration689 = null;

		CSharpParser.operatordeclaration_return operatordeclaration690 = null;

		CSharpParser.constructordeclaration_return constructordeclaration691 =
			null;

		CSharpParser.finalizerdeclaration_return finalizerdeclaration692 = null;

		CSharpParser.staticconstructordeclaration_return staticconstructordeclaration693 =
			null;

		CSharpParser.typedeclaration_return typedeclaration694 = null;

		RewriteRuleSubtreeStream stream_operatordeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule operatordeclaration");
		RewriteRuleSubtreeStream stream_propertydeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule propertydeclaration");
		RewriteRuleSubtreeStream stream_constantdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantdeclaration");
		RewriteRuleSubtreeStream stream_eventdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eventdeclaration");
		RewriteRuleSubtreeStream stream_fielddeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule fielddeclaration");
		RewriteRuleSubtreeStream stream_methoddeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule methoddeclaration");
		RewriteRuleSubtreeStream stream_staticconstructordeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule staticconstructordeclaration");
		RewriteRuleSubtreeStream stream_indexerdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule indexerdeclaration");
		RewriteRuleSubtreeStream stream_typedeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typedeclaration");
		RewriteRuleSubtreeStream stream_constructordeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constructordeclaration");
		RewriteRuleSubtreeStream stream_finalizerdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule finalizerdeclaration");
		try {
			// ../rsc/CSharp.g3:1502:5: ( ( ( attributes )? ( constantmodifiers )? cONST )=> constantdeclaration -> ^( ClassMemberDeclaration constantdeclaration ) | fielddeclaration -> ^( ClassMemberDeclaration fielddeclaration ) | ( methodheader )=> methoddeclaration -> ^( ClassMemberDeclaration methoddeclaration ) | propertydeclaration -> ^( ClassMemberDeclaration propertydeclaration ) | ( ( attributes )? ( eventmodifiers )? eVENT )=> eventdeclaration -> ^( ClassMemberDeclaration eventdeclaration ) | ( ( attributes )? ( indexermodifiers )? indexerdeclarator )=> indexerdeclaration -> ^( ClassMemberDeclaration indexerdeclaration ) | ( ( attributes )? operatormodifiers operatordeclarator )=> operatordeclaration -> ^( ClassMemberDeclaration operatordeclaration ) | ( ( attributes )? ( constructormodifiers )? constructordeclarator )=> constructordeclaration -> ^( ClassMemberDeclaration constructordeclaration ) | ( ( attributes )? ( eXTERN )? tILDE )=> finalizerdeclaration -> ^( ClassMemberDeclaration finalizerdeclaration ) | ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )=> staticconstructordeclaration -> ^( ClassMemberDeclaration staticconstructordeclaration ) | typedeclaration -> ^( ClassMemberDeclaration typedeclaration ) )
			int alt140 = 11;
			alt140 = this.dfa140.predict(this.input);
			switch (alt140) {
				case 1 :
				// ../rsc/CSharp.g3:1502:7: ( ( attributes )? ( constantmodifiers )? cONST )=> constantdeclaration
					{
						pushFollow(FOLLOW_constantdeclaration_in_classmemberdeclaration9532);
						constantdeclaration684 = constantdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constantdeclaration
								.add(constantdeclaration684.getTree());

						// AST REWRITE
						// elements: constantdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1503:5: -> ^( ClassMemberDeclaration constantdeclaration )
							{
								// ../rsc/CSharp.g3:1503:8: ^( ClassMemberDeclaration constantdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_constantdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1504:9: fielddeclaration
					{
						pushFollow(FOLLOW_fielddeclaration_in_classmemberdeclaration9554);
						fielddeclaration685 = fielddeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_fielddeclaration.add(fielddeclaration685
								.getTree());

						// AST REWRITE
						// elements: fielddeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1505:5: -> ^( ClassMemberDeclaration fielddeclaration )
							{
								// ../rsc/CSharp.g3:1505:8: ^( ClassMemberDeclaration fielddeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_fielddeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1506:9: ( methodheader )=> methoddeclaration
					{
						pushFollow(FOLLOW_methoddeclaration_in_classmemberdeclaration9582);
						methoddeclaration686 = methoddeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_methoddeclaration.add(methoddeclaration686
								.getTree());

						// AST REWRITE
						// elements: methoddeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1507:5: -> ^( ClassMemberDeclaration methoddeclaration )
							{
								// ../rsc/CSharp.g3:1507:8: ^( ClassMemberDeclaration methoddeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_methoddeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1508:9: propertydeclaration
					{
						pushFollow(FOLLOW_propertydeclaration_in_classmemberdeclaration9604);
						propertydeclaration687 = propertydeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_propertydeclaration
								.add(propertydeclaration687.getTree());

						// AST REWRITE
						// elements: propertydeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1509:5: -> ^( ClassMemberDeclaration propertydeclaration )
							{
								// ../rsc/CSharp.g3:1509:8: ^( ClassMemberDeclaration propertydeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_propertydeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1510:9: ( ( attributes )? ( eventmodifiers )? eVENT )=> eventdeclaration
					{
						pushFollow(FOLLOW_eventdeclaration_in_classmemberdeclaration9638);
						eventdeclaration688 = eventdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_eventdeclaration.add(eventdeclaration688
								.getTree());

						// AST REWRITE
						// elements: eventdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1511:5: -> ^( ClassMemberDeclaration eventdeclaration )
							{
								// ../rsc/CSharp.g3:1511:8: ^( ClassMemberDeclaration eventdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_eventdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:1512:9: ( ( attributes )? ( indexermodifiers )? indexerdeclarator )=> indexerdeclaration
					{
						pushFollow(FOLLOW_indexerdeclaration_in_classmemberdeclaration9672);
						indexerdeclaration689 = indexerdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_indexerdeclaration.add(indexerdeclaration689
								.getTree());

						// AST REWRITE
						// elements: indexerdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1513:5: -> ^( ClassMemberDeclaration indexerdeclaration )
							{
								// ../rsc/CSharp.g3:1513:8: ^( ClassMemberDeclaration indexerdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_indexerdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:1514:9: ( ( attributes )? operatormodifiers operatordeclarator )=> operatordeclaration
					{
						pushFollow(FOLLOW_operatordeclaration_in_classmemberdeclaration9705);
						operatordeclaration690 = operatordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_operatordeclaration
								.add(operatordeclaration690.getTree());

						// AST REWRITE
						// elements: operatordeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1515:5: -> ^( ClassMemberDeclaration operatordeclaration )
							{
								// ../rsc/CSharp.g3:1515:8: ^( ClassMemberDeclaration operatordeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_operatordeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:1516:9: ( ( attributes )? ( constructormodifiers )? constructordeclarator )=> constructordeclaration
					{
						pushFollow(FOLLOW_constructordeclaration_in_classmemberdeclaration9739);
						constructordeclaration691 = constructordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constructordeclaration
								.add(constructordeclaration691.getTree());

						// AST REWRITE
						// elements: constructordeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1517:5: -> ^( ClassMemberDeclaration constructordeclaration )
							{
								// ../rsc/CSharp.g3:1517:8: ^( ClassMemberDeclaration constructordeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_constructordeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:1518:9: ( ( attributes )? ( eXTERN )? tILDE )=> finalizerdeclaration
					{
						pushFollow(FOLLOW_finalizerdeclaration_in_classmemberdeclaration9773);
						finalizerdeclaration692 = finalizerdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_finalizerdeclaration
								.add(finalizerdeclaration692.getTree());

						// AST REWRITE
						// elements: finalizerdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1519:5: -> ^( ClassMemberDeclaration finalizerdeclaration )
							{
								// ../rsc/CSharp.g3:1519:8: ^( ClassMemberDeclaration finalizerdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_finalizerdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:1520:9: ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )=> staticconstructordeclaration
					{
						pushFollow(FOLLOW_staticconstructordeclaration_in_classmemberdeclaration9810);
						staticconstructordeclaration693 =
							staticconstructordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_staticconstructordeclaration
								.add(staticconstructordeclaration693.getTree());

						// AST REWRITE
						// elements: staticconstructordeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1521:5: -> ^( ClassMemberDeclaration staticconstructordeclaration )
							{
								// ../rsc/CSharp.g3:1521:8: ^( ClassMemberDeclaration staticconstructordeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_staticconstructordeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:1522:9: typedeclaration
					{
						pushFollow(FOLLOW_typedeclaration_in_classmemberdeclaration9832);
						typedeclaration694 = typedeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_typedeclaration.add(typedeclaration694
								.getTree());

						// AST REWRITE
						// elements: typedeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1523:5: -> ^( ClassMemberDeclaration typedeclaration )
							{
								// ../rsc/CSharp.g3:1523:8: ^( ClassMemberDeclaration typedeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ClassMemberDeclaration,
												"ClassMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_typedeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "classmemberdeclaration"

	public static class constantdeclaration_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constantdeclaration"
	// ../rsc/CSharp.g3:1526:1: constantdeclaration returns [String name] : ( attributes )? ( constantmodifiers )? cONST type constantdeclarators sEMICOLON -> ^( Constant ( attributes )? ( constantmodifiers )? cONST type constantdeclarators sEMICOLON ) ;
	public final CSharpParser.constantdeclaration_return constantdeclaration()
			throws RecognitionException {
		CSharpParser.constantdeclaration_return retval =
			new CSharpParser.constantdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes695 = null;

		CSharpParser.constantmodifiers_return constantmodifiers696 = null;

		CSharpParser.cONST_return cONST697 = null;

		CSharpParser.type_return type698 = null;

		CSharpParser.constantdeclarators_return constantdeclarators699 = null;

		CSharpParser.sEMICOLON_return sEMICOLON700 = null;

		RewriteRuleSubtreeStream stream_constantmodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantmodifiers");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_constantdeclarators =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantdeclarators");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_cONST =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cONST");
		try {
			// ../rsc/CSharp.g3:1530:5: ( ( attributes )? ( constantmodifiers )? cONST type constantdeclarators sEMICOLON -> ^( Constant ( attributes )? ( constantmodifiers )? cONST type constantdeclarators sEMICOLON ) )
			// ../rsc/CSharp.g3:1530:9: ( attributes )? ( constantmodifiers )? cONST type constantdeclarators sEMICOLON
			{
				// ../rsc/CSharp.g3:1530:9: ( attributes )?
				int alt141 = 2;
				int LA141_0 = this.input.LA(1);

				if ((LA141_0 == LBRACKET)) {
					alt141 = 1;
				}
				switch (alt141) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_constantdeclaration9872);
							attributes695 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes695.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1530:21: ( constantmodifiers )?
				int alt142 = 2;
				int LA142_0 = this.input.LA(1);

				if ((LA142_0 == INTERNAL || LA142_0 == NEW || (LA142_0 >= PRIVATE && LA142_0 <= PUBLIC))) {
					alt142 = 1;
				}
				switch (alt142) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: constantmodifiers
						{
							pushFollow(FOLLOW_constantmodifiers_in_constantdeclaration9875);
							constantmodifiers696 = constantmodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_constantmodifiers
									.add(constantmodifiers696.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_cONST_in_constantdeclaration9878);
				cONST697 = cONST();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cONST.add(cONST697.getTree());
				pushFollow(FOLLOW_type_in_constantdeclaration9880);
				type698 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type698.getTree());
				pushFollow(FOLLOW_constantdeclarators_in_constantdeclaration9882);
				constantdeclarators699 = constantdeclarators();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_constantdeclarators.add(constantdeclarators699
						.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_constantdeclaration9884);
				sEMICOLON700 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON700.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(constantdeclarators699 != null ? constantdeclarators699.name
								: null);
				}

				// AST REWRITE
				// elements: type, constantmodifiers, sEMICOLON, constantdeclarators, cONST, attributes
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1532:5: -> ^( Constant ( attributes )? ( constantmodifiers )? cONST type constantdeclarators sEMICOLON )
					{
						// ../rsc/CSharp.g3:1532:8: ^( Constant ( attributes )? ( constantmodifiers )? cONST type constantdeclarators sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Constant, "Constant"), root_1);

							// ../rsc/CSharp.g3:1532:19: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:1532:31: ( constantmodifiers )?
							if (stream_constantmodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_constantmodifiers.nextTree());

							}
							stream_constantmodifiers.reset();
							this.adaptor.addChild(root_1, stream_cONST.nextTree());
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_constantdeclarators.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constantdeclaration"

	public static class constantmodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constantmodifiers"
	// ../rsc/CSharp.g3:1535:1: constantmodifiers : ( constantmodifier )+ -> ^( Modifiers ( constantmodifier )+ ) ;
	public final CSharpParser.constantmodifiers_return constantmodifiers()
			throws RecognitionException {
		CSharpParser.constantmodifiers_return retval =
			new CSharpParser.constantmodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.constantmodifier_return constantmodifier701 = null;

		RewriteRuleSubtreeStream stream_constantmodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantmodifier");
		try {
			// ../rsc/CSharp.g3:1536:5: ( ( constantmodifier )+ -> ^( Modifiers ( constantmodifier )+ ) )
			// ../rsc/CSharp.g3:1536:9: ( constantmodifier )+
			{
				// ../rsc/CSharp.g3:1536:9: ( constantmodifier )+
				int cnt143 = 0;
				loop143: do {
					int alt143 = 2;
					int LA143_0 = this.input.LA(1);

					if ((LA143_0 == INTERNAL || LA143_0 == NEW || (LA143_0 >= PRIVATE && LA143_0 <= PUBLIC))) {
						alt143 = 1;
					}

					switch (alt143) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: constantmodifier
							{
								pushFollow(FOLLOW_constantmodifier_in_constantmodifiers9934);
								constantmodifier701 = constantmodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_constantmodifier
										.add(constantmodifier701.getTree());

							}
							break;

						default :
							if (cnt143 >= 1)
								break loop143;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(143, this.input);
							throw eee;
					}
					cnt143++;
				}
				while (true);

				// AST REWRITE
				// elements: constantmodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1537:5: -> ^( Modifiers ( constantmodifier )+ )
					{
						// ../rsc/CSharp.g3:1537:8: ^( Modifiers ( constantmodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_constantmodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_constantmodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_constantmodifier.nextTree());

							}
							stream_constantmodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constantmodifiers"

	public static class constantmodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constantmodifier"
	// ../rsc/CSharp.g3:1540:1: constantmodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE );
	public final CSharpParser.constantmodifier_return constantmodifier()
			throws RecognitionException {
		CSharpParser.constantmodifier_return retval =
			new CSharpParser.constantmodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW702 = null;

		CSharpParser.pUBLIC_return pUBLIC703 = null;

		CSharpParser.pROTECTED_return pROTECTED704 = null;

		CSharpParser.iNTERNAL_return iNTERNAL705 = null;

		CSharpParser.pRIVATE_return pRIVATE706 = null;

		try {
			// ../rsc/CSharp.g3:1541:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE )
			int alt144 = 5;
			switch (this.input.LA(1)) {
				case NEW :
					{
						alt144 = 1;
					}
					break;
				case PUBLIC :
					{
						alt144 = 2;
					}
					break;
				case PROTECTED :
					{
						alt144 = 3;
					}
					break;
				case INTERNAL :
					{
						alt144 = 4;
					}
					break;
				case PRIVATE :
					{
						alt144 = 5;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 144, 0, this.input);

					throw nvae;
			}

			switch (alt144) {
				case 1 :
				// ../rsc/CSharp.g3:1541:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_constantmodifier9967);
						nEW702 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW702.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1542:10: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_constantmodifier9978);
						pUBLIC703 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC703.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1543:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_constantmodifier9988);
						pROTECTED704 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED704.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1544:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_constantmodifier9998);
						iNTERNAL705 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL705.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1545:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_constantmodifier10008);
						pRIVATE706 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE706.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constantmodifier"

	public static class constantdeclarators_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constantdeclarators"
	// ../rsc/CSharp.g3:1548:1: constantdeclarators returns [String name] : c1= constantdeclarator ( cOMMA c2= constantdeclarator )* -> ^( ConstantDeclarators constantdeclarator ( cOMMA constantdeclarator )* ) ;
	public final CSharpParser.constantdeclarators_return constantdeclarators()
			throws RecognitionException {
		CSharpParser.constantdeclarators_return retval =
			new CSharpParser.constantdeclarators_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.constantdeclarator_return c1 = null;

		CSharpParser.constantdeclarator_return c2 = null;

		CSharpParser.cOMMA_return cOMMA707 = null;

		RewriteRuleSubtreeStream stream_constantdeclarator =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantdeclarator");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:1552:5: (c1= constantdeclarator ( cOMMA c2= constantdeclarator )* -> ^( ConstantDeclarators constantdeclarator ( cOMMA constantdeclarator )* ) )
			// ../rsc/CSharp.g3:1552:9: c1= constantdeclarator ( cOMMA c2= constantdeclarator )*
			{
				pushFollow(FOLLOW_constantdeclarator_in_constantdeclarators10039);
				c1 = constantdeclarator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_constantdeclarator.add(c1.getTree());
				if (this.state.backtracking == 0) {
					sb.append((c1 != null ? c1.name : null));
				}
				// ../rsc/CSharp.g3:1553:6: ( cOMMA c2= constantdeclarator )*
				loop145: do {
					int alt145 = 2;
					int LA145_0 = this.input.LA(1);

					if ((LA145_0 == COMMA)) {
						alt145 = 1;
					}

					switch (alt145) {
						case 1 :
						// ../rsc/CSharp.g3:1553:7: cOMMA c2= constantdeclarator
							{
								pushFollow(FOLLOW_cOMMA_in_constantdeclarators10049);
								cOMMA707 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_cOMMA.add(cOMMA707.getTree());
								pushFollow(FOLLOW_constantdeclarator_in_constantdeclarators10053);
								c2 = constantdeclarator();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_constantdeclarator.add(c2.getTree());
								if (this.state.backtracking == 0) {
									sb.append(',').append(
										(c2 != null ? c2.name : null));
								}

							}
							break;

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

				if (this.state.backtracking == 0) {
					retval.name = sb.toString();
				}

				// AST REWRITE
				// elements: constantdeclarator, cOMMA, constantdeclarator
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1555:5: -> ^( ConstantDeclarators constantdeclarator ( cOMMA constantdeclarator )* )
					{
						// ../rsc/CSharp.g3:1555:8: ^( ConstantDeclarators constantdeclarator ( cOMMA constantdeclarator )* )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ConstantDeclarators,
										"ConstantDeclarators"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_constantdeclarator.nextTree());
							// ../rsc/CSharp.g3:1555:49: ( cOMMA constantdeclarator )*
							while (stream_cOMMA.hasNext()
									|| stream_constantdeclarator.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_cOMMA.nextTree());
								this.adaptor.addChild(
									root_1,
									stream_constantdeclarator.nextTree());

							}
							stream_cOMMA.reset();
							stream_constantdeclarator.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constantdeclarators"

	public static class constantdeclarator_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constantdeclarator"
	// ../rsc/CSharp.g3:1558:1: constantdeclarator returns [String name] : identifier aSSIGN constantexpression -> ^( ConstantDeclarator identifier aSSIGN constantexpression ) ;
	public final CSharpParser.constantdeclarator_return constantdeclarator()
			throws RecognitionException {
		CSharpParser.constantdeclarator_return retval =
			new CSharpParser.constantdeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier708 = null;

		CSharpParser.aSSIGN_return aSSIGN709 = null;

		CSharpParser.constantexpression_return constantexpression710 = null;

		RewriteRuleSubtreeStream stream_constantexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantexpression");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_aSSIGN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aSSIGN");
		try {
			// ../rsc/CSharp.g3:1559:5: ( identifier aSSIGN constantexpression -> ^( ConstantDeclarator identifier aSSIGN constantexpression ) )
			// ../rsc/CSharp.g3:1559:9: identifier aSSIGN constantexpression
			{
				pushFollow(FOLLOW_identifier_in_constantdeclarator10106);
				identifier708 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier708.getTree());
				pushFollow(FOLLOW_aSSIGN_in_constantdeclarator10108);
				aSSIGN709 = aSSIGN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_aSSIGN.add(aSSIGN709.getTree());
				pushFollow(FOLLOW_constantexpression_in_constantdeclarator10110);
				constantexpression710 = constantexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_constantexpression.add(constantexpression710
						.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(identifier708 != null ? identifier708.content : null);
				}

				// AST REWRITE
				// elements: aSSIGN, constantexpression, identifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1561:5: -> ^( ConstantDeclarator identifier aSSIGN constantexpression )
					{
						// ../rsc/CSharp.g3:1561:8: ^( ConstantDeclarator identifier aSSIGN constantexpression )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ConstantDeclarator,
										"ConstantDeclarator"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							this.adaptor.addChild(root_1, stream_aSSIGN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_constantexpression.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constantdeclarator"

	public static class fielddeclaration_return extends ParserRuleReturnScope {
		public String name;
		public String Type;
		public int Cardinality;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fielddeclaration"
	// ../rsc/CSharp.g3:1564:1: fielddeclaration returns [String name, String Type, int Cardinality] : ( attributes )? ( fieldmodifiers )? type variabledeclarators sEMICOLON -> ^( Field ( attributes )? ( fieldmodifiers )? type variabledeclarators sEMICOLON ) ;
	public final CSharpParser.fielddeclaration_return fielddeclaration()
			throws RecognitionException {
		CSharpParser.fielddeclaration_return retval =
			new CSharpParser.fielddeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes711 = null;

		CSharpParser.fieldmodifiers_return fieldmodifiers712 = null;

		CSharpParser.type_return type713 = null;

		CSharpParser.variabledeclarators_return variabledeclarators714 = null;

		CSharpParser.sEMICOLON_return sEMICOLON715 = null;

		RewriteRuleSubtreeStream stream_fieldmodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule fieldmodifiers");
		RewriteRuleSubtreeStream stream_variabledeclarators =
			new RewriteRuleSubtreeStream(this.adaptor, "rule variabledeclarators");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:1628:5: ( ( attributes )? ( fieldmodifiers )? type variabledeclarators sEMICOLON -> ^( Field ( attributes )? ( fieldmodifiers )? type variabledeclarators sEMICOLON ) )
			// ../rsc/CSharp.g3:1628:9: ( attributes )? ( fieldmodifiers )? type variabledeclarators sEMICOLON
			{
				// ../rsc/CSharp.g3:1628:9: ( attributes )?
				int alt146 = 2;
				int LA146_0 = this.input.LA(1);

				if ((LA146_0 == LBRACKET)) {
					alt146 = 1;
				}
				switch (alt146) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_fielddeclaration10167);
							attributes711 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes711.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1628:21: ( fieldmodifiers )?
				int alt147 = 2;
				int LA147_0 = this.input.LA(1);

				if ((LA147_0 == INTERNAL || LA147_0 == NEW
						|| (LA147_0 >= PRIVATE && LA147_0 <= READONLY)
						|| LA147_0 == STATIC || LA147_0 == VOLATILE)) {
					alt147 = 1;
				}
				switch (alt147) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: fieldmodifiers
						{
							pushFollow(FOLLOW_fieldmodifiers_in_fielddeclaration10170);
							fieldmodifiers712 = fieldmodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_fieldmodifiers.add(fieldmodifiers712
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_type_in_fielddeclaration10173);
				type713 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type713.getTree());
				pushFollow(FOLLOW_variabledeclarators_in_fielddeclaration10175);
				variabledeclarators714 = variabledeclarators();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_variabledeclarators.add(variabledeclarators714
						.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_fielddeclaration10177);
				sEMICOLON715 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON715.getTree());
				if (this.state.backtracking == 0) {

					retval.name =
						(variabledeclarators714 != null ? variabledeclarators714.name
								: null);
					{
						retval.Type = (type713 != null ? type713.name : null);
					}

				}

				// AST REWRITE
				// elements: attributes, variabledeclarators, fieldmodifiers, sEMICOLON, type
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1633:5: -> ^( Field ( attributes )? ( fieldmodifiers )? type variabledeclarators sEMICOLON )
					{
						// ../rsc/CSharp.g3:1633:8: ^( Field ( attributes )? ( fieldmodifiers )? type variabledeclarators sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Field, "Field"),
									root_1);

							// ../rsc/CSharp.g3:1633:16: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:1633:28: ( fieldmodifiers )?
							if (stream_fieldmodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_fieldmodifiers.nextTree());

							}
							stream_fieldmodifiers.reset();
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_variabledeclarators.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				//tokenNameMap.put(((Object)retval.tree), retval.name, retval.Type);

				//System.out.println(((Object)retval.tree));
				//System.out.println(retval.name);
				//System.out.println("la mama");
					this.element1 =
						this.getFactory().createField(
							retval.name.toCharArray(),
							retval.name.toCharArray(),
							retval.Type.toCharArray(),
							1);
					//		if (methodstock = true) {
					//			MethodStockBody.add(element1);
					//			ElementMethodNumber = ElementMethodNumber + 1;
					//		}
					this.classStockBody.add(this.element1);

					if (this.Fieldmodifier == Modifier.PUBLIC) {
						this.element1.setPublic(true);
						//System.out.println("voila yousra");
					}
					else if (this.Fieldmodifier == Modifier.PRIVATE) {
						this.element1.setPrivate(true);
						//System.out.println("voila yousra");

					}
					if (this.Fieldmodifier == Modifier.PROTECTED) {
						this.element1.setProtected(true);
						//System.out.println("voila yousra");

					}
					if (this.Fieldmodifier == Modifier.STATIC) {
						this.element1.setStatic(true);
						//System.out.println("voila yousra");

					}

					if (this.Fieldmodifier == Modifier.VOLATILE) {
						//element1.setStatic(true);

					}

					//System.out.print(Modifier.toString(this.Fieldmodifier) + " ");
					//System.out.print(retval.Type + " ");
					//System.out.println(retval.name + " ");
					//System.out.println(((Object)retval.tree));
					//		System.out.print("class "+retval.name); 	
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fielddeclaration"

	public static class fieldmodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fieldmodifiers"
	// ../rsc/CSharp.g3:1636:1: fieldmodifiers : ( fieldmodifier )+ -> ^( Modifiers ( fieldmodifier )+ ) ;
	public final CSharpParser.fieldmodifiers_return fieldmodifiers()
			throws RecognitionException {
		CSharpParser.fieldmodifiers_return retval =
			new CSharpParser.fieldmodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.fieldmodifier_return fieldmodifier716 = null;

		RewriteRuleSubtreeStream stream_fieldmodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule fieldmodifier");
		try {
			// ../rsc/CSharp.g3:1637:5: ( ( fieldmodifier )+ -> ^( Modifiers ( fieldmodifier )+ ) )
			// ../rsc/CSharp.g3:1637:9: ( fieldmodifier )+
			{
				// ../rsc/CSharp.g3:1637:9: ( fieldmodifier )+
				int cnt148 = 0;
				loop148: do {
					int alt148 = 2;
					int LA148_0 = this.input.LA(1);

					if ((LA148_0 == INTERNAL || LA148_0 == NEW
							|| (LA148_0 >= PRIVATE && LA148_0 <= READONLY)
							|| LA148_0 == STATIC || LA148_0 == VOLATILE)) {
						alt148 = 1;
					}

					switch (alt148) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: fieldmodifier
							{
								pushFollow(FOLLOW_fieldmodifier_in_fieldmodifiers10225);
								fieldmodifier716 = fieldmodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_fieldmodifier.add(fieldmodifier716
										.getTree());

							}
							break;

						default :
							if (cnt148 >= 1)
								break loop148;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(148, this.input);
							throw eee;
					}
					cnt148++;
				}
				while (true);

				// AST REWRITE
				// elements: fieldmodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1638:5: -> ^( Modifiers ( fieldmodifier )+ )
					{
						// ../rsc/CSharp.g3:1638:8: ^( Modifiers ( fieldmodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_fieldmodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_fieldmodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_fieldmodifier.nextTree());

							}
							stream_fieldmodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fieldmodifiers"

	public static class fieldmodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fieldmodifier"
	// ../rsc/CSharp.g3:1641:1: fieldmodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | rEADONLY | vOLATILE );
	public final CSharpParser.fieldmodifier_return fieldmodifier()
			throws RecognitionException {
		CSharpParser.fieldmodifier_return retval =
			new CSharpParser.fieldmodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW717 = null;

		CSharpParser.pUBLIC_return pUBLIC718 = null;

		CSharpParser.pROTECTED_return pROTECTED719 = null;

		CSharpParser.iNTERNAL_return iNTERNAL720 = null;

		CSharpParser.pRIVATE_return pRIVATE721 = null;

		CSharpParser.sTATIC_return sTATIC722 = null;

		CSharpParser.rEADONLY_return rEADONLY723 = null;

		CSharpParser.vOLATILE_return vOLATILE724 = null;

		try {
			// ../rsc/CSharp.g3:1642:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | rEADONLY | vOLATILE )
			int alt149 = 8;
			switch (this.input.LA(1)) {
				case NEW :
					{
						alt149 = 1;
					}
					break;
				case PUBLIC :
					{
						alt149 = 2;
					}
					break;
				case PROTECTED :
					{
						alt149 = 3;
					}
					break;
				case INTERNAL :
					{
						alt149 = 4;
					}
					break;
				case PRIVATE :
					{
						alt149 = 5;
					}
					break;
				case STATIC :
					{
						alt149 = 6;
					}
					break;
				case READONLY :
					{
						alt149 = 7;
					}
					break;
				case VOLATILE :
					{
						alt149 = 8;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 149, 0, this.input);

					throw nvae;
			}

			switch (alt149) {
				case 1 :
				// ../rsc/CSharp.g3:1642:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_fieldmodifier10258);
						nEW717 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW717.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(nEW717.getTree());
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1644:10: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_fieldmodifier10275);
						pUBLIC718 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC718.getTree());
						if (this.state.backtracking == 0) {
							this.Fieldmodifier = Modifier.PUBLIC;
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1646:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_fieldmodifier10288);
						pROTECTED719 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED719.getTree());
						if (this.state.backtracking == 0) {
							this.Fieldmodifier = Modifier.PROTECTED;
						}

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1648:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_fieldmodifier10302);
						iNTERNAL720 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL720.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(iNTERNAL720.getTree());
						}

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1650:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_fieldmodifier10319);
						pRIVATE721 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE721.getTree());
						if (this.state.backtracking == 0) {
							this.Fieldmodifier = Modifier.PRIVATE;
						}

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:1652:9: sTATIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTATIC_in_fieldmodifier10332);
						sTATIC722 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTATIC722.getTree());
						if (this.state.backtracking == 0) {
							this.Fieldmodifier = Modifier.STATIC;
						}

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:1654:9: rEADONLY
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_rEADONLY_in_fieldmodifier10347);
						rEADONLY723 = rEADONLY();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, rEADONLY723.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(rEADONLY723.getTree());
						}

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:1656:9: vOLATILE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vOLATILE_in_fieldmodifier10363);
						vOLATILE724 = vOLATILE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vOLATILE724.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(vOLATILE724.getTree());
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fieldmodifier"

	public static class variabledeclarators_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "variabledeclarators"
	// ../rsc/CSharp.g3:1660:1: variabledeclarators returns [String name] : v1= variabledeclarator ( cOMMA v2= variabledeclarator )* -> ^( VariableDeclarators variabledeclarator ( cOMMA variabledeclarator )* ) ;
	public final CSharpParser.variabledeclarators_return variabledeclarators()
			throws RecognitionException {
		CSharpParser.variabledeclarators_return retval =
			new CSharpParser.variabledeclarators_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.variabledeclarator_return v1 = null;

		CSharpParser.variabledeclarator_return v2 = null;

		CSharpParser.cOMMA_return cOMMA725 = null;

		RewriteRuleSubtreeStream stream_variabledeclarator =
			new RewriteRuleSubtreeStream(this.adaptor, "rule variabledeclarator");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:1664:5: (v1= variabledeclarator ( cOMMA v2= variabledeclarator )* -> ^( VariableDeclarators variabledeclarator ( cOMMA variabledeclarator )* ) )
			// ../rsc/CSharp.g3:1664:9: v1= variabledeclarator ( cOMMA v2= variabledeclarator )*
			{
				pushFollow(FOLLOW_variabledeclarator_in_variabledeclarators10399);
				v1 = variabledeclarator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_variabledeclarator.add(v1.getTree());
				if (this.state.backtracking == 0) {
					sb.append((v1 != null ? v1.name : null));
				}
				// ../rsc/CSharp.g3:1665:6: ( cOMMA v2= variabledeclarator )*
				loop150: do {
					int alt150 = 2;
					int LA150_0 = this.input.LA(1);

					if ((LA150_0 == COMMA)) {
						alt150 = 1;
					}

					switch (alt150) {
						case 1 :
						// ../rsc/CSharp.g3:1665:7: cOMMA v2= variabledeclarator
							{
								pushFollow(FOLLOW_cOMMA_in_variabledeclarators10409);
								cOMMA725 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_cOMMA.add(cOMMA725.getTree());
								pushFollow(FOLLOW_variabledeclarator_in_variabledeclarators10413);
								v2 = variabledeclarator();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_variabledeclarator.add(v2.getTree());
								if (this.state.backtracking == 0) {
									sb.append(',').append(
										(v2 != null ? v2.name : null));
								}

							}
							break;

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

				if (this.state.backtracking == 0) {
					retval.name = sb.toString();
				}

				// AST REWRITE
				// elements: variabledeclarator, variabledeclarator, cOMMA
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1667:5: -> ^( VariableDeclarators variabledeclarator ( cOMMA variabledeclarator )* )
					{
						// ../rsc/CSharp.g3:1667:8: ^( VariableDeclarators variabledeclarator ( cOMMA variabledeclarator )* )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										VariableDeclarators,
										"VariableDeclarators"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_variabledeclarator.nextTree());
							// ../rsc/CSharp.g3:1667:49: ( cOMMA variabledeclarator )*
							while (stream_variabledeclarator.hasNext()
									|| stream_cOMMA.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_cOMMA.nextTree());
								this.adaptor.addChild(
									root_1,
									stream_variabledeclarator.nextTree());

							}
							stream_variabledeclarator.reset();
							stream_cOMMA.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "variabledeclarators"

	public static class variabledeclarator_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "variabledeclarator"
	// ../rsc/CSharp.g3:1670:1: variabledeclarator returns [String name] : identifier ( aSSIGN variableinitializer )? -> ^( VariableDeclarator identifier ( aSSIGN variableinitializer )? ) ;
	public final CSharpParser.variabledeclarator_return variabledeclarator()
			throws RecognitionException {
		CSharpParser.variabledeclarator_return retval =
			new CSharpParser.variabledeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier726 = null;

		CSharpParser.aSSIGN_return aSSIGN727 = null;

		CSharpParser.variableinitializer_return variableinitializer728 = null;

		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_variableinitializer =
			new RewriteRuleSubtreeStream(this.adaptor, "rule variableinitializer");
		RewriteRuleSubtreeStream stream_aSSIGN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aSSIGN");
		try {
			// ../rsc/CSharp.g3:1671:5: ( identifier ( aSSIGN variableinitializer )? -> ^( VariableDeclarator identifier ( aSSIGN variableinitializer )? ) )
			// ../rsc/CSharp.g3:1671:9: identifier ( aSSIGN variableinitializer )?
			{
				pushFollow(FOLLOW_identifier_in_variabledeclarator10466);
				identifier726 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier726.getTree());
				// ../rsc/CSharp.g3:1671:20: ( aSSIGN variableinitializer )?
				int alt151 = 2;
				int LA151_0 = this.input.LA(1);

				if ((LA151_0 == ASSIGN)) {
					alt151 = 1;
				}
				switch (alt151) {
					case 1 :
					// ../rsc/CSharp.g3:1671:21: aSSIGN variableinitializer
						{
							pushFollow(FOLLOW_aSSIGN_in_variabledeclarator10469);
							aSSIGN727 = aSSIGN();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_aSSIGN.add(aSSIGN727.getTree());
							pushFollow(FOLLOW_variableinitializer_in_variabledeclarator10471);
							variableinitializer728 = variableinitializer();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_variableinitializer
									.add(variableinitializer728.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {
					retval.name =
						(identifier726 != null ? identifier726.content : null);
				}

				// AST REWRITE
				// elements: identifier, variableinitializer, aSSIGN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1673:5: -> ^( VariableDeclarator identifier ( aSSIGN variableinitializer )? )
					{
						// ../rsc/CSharp.g3:1673:8: ^( VariableDeclarator identifier ( aSSIGN variableinitializer )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										VariableDeclarator,
										"VariableDeclarator"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:1673:40: ( aSSIGN variableinitializer )?
							if (stream_variableinitializer.hasNext()
									|| stream_aSSIGN.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_aSSIGN.nextTree());
								this.adaptor.addChild(
									root_1,
									stream_variableinitializer.nextTree());

							}
							stream_variableinitializer.reset();
							stream_aSSIGN.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "variabledeclarator"

	public static class methoddeclaration_return extends ParserRuleReturnScope {
		public String signature;
		public String membername;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "methoddeclaration"
	// ../rsc/CSharp.g3:1678:1: methoddeclaration returns [String signature, String membername] : methodheader methodbody -> ^( Method methodheader methodbody ) ;
	public final CSharpParser.methoddeclaration_return methoddeclaration()
			throws RecognitionException {
		CSharpParser.methoddeclaration_return retval =
			new CSharpParser.methoddeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.methodheader_return methodheader729 = null;

		CSharpParser.methodbody_return methodbody730 = null;

		RewriteRuleSubtreeStream stream_methodheader =
			new RewriteRuleSubtreeStream(this.adaptor, "rule methodheader");
		RewriteRuleSubtreeStream stream_methodbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule methodbody");
		try {
			// ../rsc/CSharp.g3:1748:5: ( methodheader methodbody -> ^( Method methodheader methodbody ) )
			// ../rsc/CSharp.g3:1748:9: methodheader methodbody
			{
				pushFollow(FOLLOW_methodheader_in_methoddeclaration10529);
				methodheader729 = methodheader();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_methodheader.add(methodheader729.getTree());
				pushFollow(FOLLOW_methodbody_in_methoddeclaration10531);
				methodbody730 = methodbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_methodbody.add(methodbody730.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(methodheader729 != null ? methodheader729.signature
								: null)
								+ (methodheader729 != null ? methodheader729.membername
										: null);
				}

				// AST REWRITE
				// elements: methodbody, methodheader
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1749:5: -> ^( Method methodheader methodbody )
					{
						// ../rsc/CSharp.g3:1749:8: ^( Method methodheader methodbody )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Method, "Method"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_methodheader.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_methodbody.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {
				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {
				this.tokenNameMap.put(((Object) retval.tree), retval.signature);

					this.element =
						this.getFactory().createMethod(
							retval.signature.toCharArray(),
							retval.signature.toCharArray());

					this.classStockBody.add(this.element);
					this.ElementclassNumber = this.ElementclassNumber + 1;

					for (int i = 0; i < this.ElementMethodNumber; i++) {
						((IMethod) this.element)
							.addConstituent((IConstituentOfOperation) this.MethodStockBody
								.get(i));
					}
					//System.out.println("le nombre de constituent de la methode est " + this.element.getNumberOfConstituents());

					//maclass.addConstituent(element);

					if (this.MethodModifier == Modifier.PUBLIC) {
						this.element.setPublic(true);
						//System.out.println("voila yousra");
					}
					if (this.MethodModifier == Modifier.PROTECTED) {
						this.element.setProtected(true);
						//System.out.println("voila yousra");

					}
					if (this.MethodModifier == Modifier.PRIVATE) {
						this.element.setPrivate(true);
						//System.out.println("voila yousra");

					}

					if (this.MethodModifier == Modifier.STATIC) {
						this.element.setStatic(true);
						//System.out.println("voila yousra");

					}

					if (this.MethodModifier == Modifier.ABSTRACT) {
						this.element.setAbstract(true);
						//System.out.println("voila yousra");

					}

					//System.out.print(Modifier.toString(this.MethodModifier) + " " + this.MethodReturn + " ");
					//System.out.println(retval.signature);

					this.Methordreturns = (this.MethodReturn.toString()).toCharArray();
					//Element PADL
					this.element.setReturnType(this.Methordreturns);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "methoddeclaration"

	public static class methodheader_return extends ParserRuleReturnScope {
		public String signature;
		public String membername;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "methodheader"
	// ../rsc/CSharp.g3:1753:1: methodheader returns [String signature, String membername] : ( attributes )? ( methodmodifiers )? returntype membername ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? -> ( attributes )? ( methodmodifiers )? returntype membername ( typeparameterlist )? ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( typeparameterconstraintsclauses )? ;
	public final CSharpParser.methodheader_return methodheader()
			throws RecognitionException {
		CSharpParser.methodheader_return retval =
			new CSharpParser.methodheader_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes731 = null;

		CSharpParser.methodmodifiers_return methodmodifiers732 = null;

		CSharpParser.returntype_return returntype733 = null;

		CSharpParser.membername_return membername734 = null;

		CSharpParser.typeparameterlist_return typeparameterlist735 = null;

		CSharpParser.lPAREN_return lPAREN736 = null;

		CSharpParser.formalparameterlist_return formalparameterlist737 = null;

		CSharpParser.rPAREN_return rPAREN738 = null;

		CSharpParser.typeparameterconstraintsclauses_return typeparameterconstraintsclauses739 =
			null;

		RewriteRuleSubtreeStream stream_typeparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameterlist");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_typeparameterconstraintsclauses =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule typeparameterconstraintsclauses");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_methodmodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule methodmodifiers");
		RewriteRuleSubtreeStream stream_membername =
			new RewriteRuleSubtreeStream(this.adaptor, "rule membername");
		RewriteRuleSubtreeStream stream_formalparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule formalparameterlist");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_returntype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule returntype");

		String formalParams = "";
		String typeParams = "";

		try {
			// ../rsc/CSharp.g3:1758:5: ( ( attributes )? ( methodmodifiers )? returntype membername ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? -> ( attributes )? ( methodmodifiers )? returntype membername ( typeparameterlist )? ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( typeparameterconstraintsclauses )? )
			// ../rsc/CSharp.g3:1758:9: ( attributes )? ( methodmodifiers )? returntype membername ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )?
			{
				// ../rsc/CSharp.g3:1758:9: ( attributes )?
				int alt152 = 2;
				int LA152_0 = this.input.LA(1);

				if ((LA152_0 == LBRACKET)) {
					alt152 = 1;
				}
				switch (alt152) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_methodheader10576);
							attributes731 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes731.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1759:6: ( methodmodifiers )?
				int alt153 = 2;
				int LA153_0 = this.input.LA(1);

				if ((LA153_0 == ABSTRACT || LA153_0 == EXTERN
						|| LA153_0 == INTERNAL || LA153_0 == NEW
						|| LA153_0 == OVERRIDE
						|| (LA153_0 >= PRIVATE && LA153_0 <= PUBLIC)
						|| LA153_0 == SEALED || LA153_0 == STATIC || LA153_0 == VIRTUAL)) {
					alt153 = 1;
				}
				switch (alt153) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: methodmodifiers
						{
							pushFollow(FOLLOW_methodmodifiers_in_methodheader10584);
							methodmodifiers732 = methodmodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_methodmodifiers.add(methodmodifiers732
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_returntype_in_methodheader10592);
				returntype733 = returntype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_returntype.add(returntype733.getTree());
				pushFollow(FOLLOW_membername_in_methodheader10599);
				membername734 = membername();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_membername.add(membername734.getTree());
				// ../rsc/CSharp.g3:1763:6: ( typeparameterlist )?
				int alt154 = 2;
				int LA154_0 = this.input.LA(1);

				if ((LA154_0 == LT)) {
					alt154 = 1;
				}
				switch (alt154) {
					case 1 :
					// ../rsc/CSharp.g3:1763:7: typeparameterlist
						{
							pushFollow(FOLLOW_typeparameterlist_in_methodheader10613);
							typeparameterlist735 = typeparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterlist
									.add(typeparameterlist735.getTree());
							if (this.state.backtracking == 0) {
								typeParams =
									(typeparameterlist735 != null ? typeparameterlist735.signature
											: null);
							}

						}
						break;

				}

				pushFollow(FOLLOW_lPAREN_in_methodheader10624);
				lPAREN736 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN736.getTree());
				// ../rsc/CSharp.g3:1766:6: ( formalparameterlist )?
				int alt155 = 2;
				int LA155_0 = this.input.LA(1);

				if ((LA155_0 == LBRACKET || LA155_0 == BOOL || LA155_0 == BYTE
						|| LA155_0 == CHAR || LA155_0 == DECIMAL
						|| LA155_0 == DOUBLE || LA155_0 == FLOAT
						|| LA155_0 == INT || LA155_0 == LONG
						|| LA155_0 == OBJECT || LA155_0 == OUT
						|| LA155_0 == PARAMS || LA155_0 == REF
						|| LA155_0 == SBYTE || LA155_0 == SHORT
						|| LA155_0 == STRING
						|| (LA155_0 >= UINT && LA155_0 <= ULONG)
						|| LA155_0 == USHORT || (LA155_0 >= ADD && LA155_0 <= Ident))) {
					alt155 = 1;
				}
				switch (alt155) {
					case 1 :
					// ../rsc/CSharp.g3:1766:7: formalparameterlist
						{
							pushFollow(FOLLOW_formalparameterlist_in_methodheader10638);
							formalparameterlist737 = formalparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_formalparameterlist
									.add(formalparameterlist737.getTree());
							if (this.state.backtracking == 0) {
								formalParams =
									(formalparameterlist737 != null ? formalparameterlist737.signature
											: null);
							}

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_methodheader10649);
				rPAREN738 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN738.getTree());
				// ../rsc/CSharp.g3:1768:6: ( typeparameterconstraintsclauses )?
				int alt156 = 2;
				int LA156_0 = this.input.LA(1);

				if ((LA156_0 == WHERE)) {
					alt156 = 1;
				}
				switch (alt156) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterconstraintsclauses
						{
							pushFollow(FOLLOW_typeparameterconstraintsclauses_in_methodheader10656);
							typeparameterconstraintsclauses739 =
								typeparameterconstraintsclauses();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterconstraintsclauses
									.add(typeparameterconstraintsclauses739
										.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {
					retval.signature =
						(membername734 != null ? membername734.name : null)
								+ typeParams + '(' + formalParams + ')';
				}

				// AST REWRITE
				// elements: lPAREN, methodmodifiers, returntype, typeparameterconstraintsclauses, rPAREN, attributes, membername, formalparameterlist, typeparameterlist
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1773:5: -> ( attributes )? ( methodmodifiers )? returntype membername ( typeparameterlist )? ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( typeparameterconstraintsclauses )?
					{
						// ../rsc/CSharp.g3:1773:9: ( attributes )?
						if (stream_attributes.hasNext()) {
							this.adaptor.addChild(
								root_0,
								stream_attributes.nextTree());

						}
						stream_attributes.reset();
						// ../rsc/CSharp.g3:1773:21: ( methodmodifiers )?
						if (stream_methodmodifiers.hasNext()) {
							this.adaptor.addChild(
								root_0,
								stream_methodmodifiers.nextTree());

						}
						stream_methodmodifiers.reset();
						this.adaptor.addChild(root_0, stream_returntype.nextTree());
						this.adaptor.addChild(root_0, stream_membername.nextTree());
						// ../rsc/CSharp.g3:1773:60: ( typeparameterlist )?
						if (stream_typeparameterlist.hasNext()) {
							this.adaptor.addChild(
								root_0,
								stream_typeparameterlist.nextTree());

						}
						stream_typeparameterlist.reset();
						// ../rsc/CSharp.g3:1774:7: ^( ParameterList lPAREN ( formalparameterlist )? rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ParameterList,
										"ParameterList"),
									root_1);

							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							// ../rsc/CSharp.g3:1774:30: ( formalparameterlist )?
							if (stream_formalparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_formalparameterlist.nextTree());

							}
							stream_formalparameterlist.reset();
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}
						// ../rsc/CSharp.g3:1774:59: ( typeparameterconstraintsclauses )?
						if (stream_typeparameterconstraintsclauses.hasNext()) {
							this.adaptor.addChild(
								root_0,
								stream_typeparameterconstraintsclauses
									.nextTree());

						}
						stream_typeparameterconstraintsclauses.reset();

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "methodheader"

	public static class methodmodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "methodmodifiers"
	// ../rsc/CSharp.g3:1777:1: methodmodifiers : ( methodmodifier )+ -> ^( Modifiers ( methodmodifier )+ ) ;
	public final CSharpParser.methodmodifiers_return methodmodifiers()
			throws RecognitionException {
		CSharpParser.methodmodifiers_return retval =
			new CSharpParser.methodmodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.methodmodifier_return methodmodifier740 = null;

		RewriteRuleSubtreeStream stream_methodmodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule methodmodifier");
		try {
			// ../rsc/CSharp.g3:1778:5: ( ( methodmodifier )+ -> ^( Modifiers ( methodmodifier )+ ) )
			// ../rsc/CSharp.g3:1778:9: ( methodmodifier )+
			{
				// ../rsc/CSharp.g3:1778:9: ( methodmodifier )+
				int cnt157 = 0;
				loop157: do {
					int alt157 = 2;
					int LA157_0 = this.input.LA(1);

					if ((LA157_0 == ABSTRACT || LA157_0 == EXTERN
							|| LA157_0 == INTERNAL || LA157_0 == NEW
							|| LA157_0 == OVERRIDE
							|| (LA157_0 >= PRIVATE && LA157_0 <= PUBLIC)
							|| LA157_0 == SEALED || LA157_0 == STATIC || LA157_0 == VIRTUAL)) {
						alt157 = 1;
					}

					switch (alt157) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: methodmodifier
							{
								pushFollow(FOLLOW_methodmodifier_in_methodmodifiers10741);
								methodmodifier740 = methodmodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_methodmodifier.add(methodmodifier740
										.getTree());

							}
							break;

						default :
							if (cnt157 >= 1)
								break loop157;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(157, this.input);
							throw eee;
					}
					cnt157++;
				}
				while (true);

				// AST REWRITE
				// elements: methodmodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1779:5: -> ^( Modifiers ( methodmodifier )+ )
					{
						// ../rsc/CSharp.g3:1779:8: ^( Modifiers ( methodmodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_methodmodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_methodmodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_methodmodifier.nextTree());

							}
							stream_methodmodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "methodmodifiers"

	public static class methodmodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "methodmodifier"
	// ../rsc/CSharp.g3:1782:1: methodmodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN );
	public final CSharpParser.methodmodifier_return methodmodifier()
			throws RecognitionException {
		CSharpParser.methodmodifier_return retval =
			new CSharpParser.methodmodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW741 = null;

		CSharpParser.pUBLIC_return pUBLIC742 = null;

		CSharpParser.pROTECTED_return pROTECTED743 = null;

		CSharpParser.iNTERNAL_return iNTERNAL744 = null;

		CSharpParser.pRIVATE_return pRIVATE745 = null;

		CSharpParser.sTATIC_return sTATIC746 = null;

		CSharpParser.vIRTUAL_return vIRTUAL747 = null;

		CSharpParser.sEALED_return sEALED748 = null;

		CSharpParser.oVERRIDE_return oVERRIDE749 = null;

		CSharpParser.aBSTRACT_return aBSTRACT750 = null;

		CSharpParser.eXTERN_return eXTERN751 = null;

		try {
			// ../rsc/CSharp.g3:1783:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN )
			int alt158 = 11;
			alt158 = this.dfa158.predict(this.input);
			switch (alt158) {
				case 1 :
				// ../rsc/CSharp.g3:1783:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_methodmodifier10774);
						nEW741 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW741.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(nEW741.getTree());
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1785:10: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_methodmodifier10790);
						pUBLIC742 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC742.getTree());
						if (this.state.backtracking == 0) {
							this.MethodModifier = Modifier.PUBLIC;
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1787:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_methodmodifier10804);
						pROTECTED743 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED743.getTree());
						if (this.state.backtracking == 0) {
							this.MethodModifier = Modifier.PROTECTED;
						}

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1789:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_methodmodifier10820);
						iNTERNAL744 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL744.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(iNTERNAL744.getTree() + " ");
						}

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1791:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_methodmodifier10835);
						pRIVATE745 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE745.getTree());
						if (this.state.backtracking == 0) {
							this.MethodModifier = Modifier.PRIVATE;
						}

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:1793:9: sTATIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTATIC_in_methodmodifier10850);
						sTATIC746 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTATIC746.getTree());
						if (this.state.backtracking == 0) {
							this.MethodModifier = Modifier.STATIC;
						}

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:1795:9: vIRTUAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vIRTUAL_in_methodmodifier10865);
						vIRTUAL747 = vIRTUAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vIRTUAL747.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(vIRTUAL747.getTree() + " ");
						}

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:1797:9: sEALED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEALED_in_methodmodifier10880);
						sEALED748 = sEALED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEALED748.getTree());
						if (this.state.backtracking == 0) {
							// System.out.println(vIRTUAL747.getTree() + " ");
						}

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:1799:9: oVERRIDE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oVERRIDE_in_methodmodifier10896);
						oVERRIDE749 = oVERRIDE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oVERRIDE749.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(oVERRIDE749.getTree() + " ");
						}

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:1801:9: aBSTRACT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aBSTRACT_in_methodmodifier10911);
						aBSTRACT750 = aBSTRACT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aBSTRACT750.getTree());
						if (this.state.backtracking == 0) {
							this.MethodModifier = Modifier.ABSTRACT;
						}

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:1803:9: eXTERN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXTERN_in_methodmodifier10926);
						eXTERN751 = eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXTERN751.getTree());
						if (this.state.backtracking == 0) {
							//System.out.println(eXTERN751.getTree() + " ");
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "methodmodifier"

	public static class returntype_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "returntype"
	// ../rsc/CSharp.g3:1807:1: returntype : ( type | vOID );
	public final CSharpParser.returntype_return returntype()
			throws RecognitionException {
		CSharpParser.returntype_return retval =
			new CSharpParser.returntype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.type_return type752 = null;

		CSharpParser.vOID_return vOID753 = null;

		try {
			// ../rsc/CSharp.g3:1808:5: ( type | vOID )
			int alt159 = 2;
			int LA159_0 = this.input.LA(1);

			if ((LA159_0 == BOOL || LA159_0 == BYTE || LA159_0 == CHAR
					|| LA159_0 == DECIMAL || LA159_0 == DOUBLE
					|| LA159_0 == FLOAT || LA159_0 == INT || LA159_0 == LONG
					|| LA159_0 == OBJECT || LA159_0 == SBYTE
					|| LA159_0 == SHORT || LA159_0 == STRING
					|| (LA159_0 >= UINT && LA159_0 <= ULONG)
					|| LA159_0 == USHORT || (LA159_0 >= ADD && LA159_0 <= Ident))) {
				alt159 = 1;
			}
			else if ((LA159_0 == VOID)) {
				alt159 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 159, 0, this.input);

				throw nvae;
			}
			switch (alt159) {
				case 1 :
				// ../rsc/CSharp.g3:1808:9: type
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_type_in_returntype10952);
						type752 = type();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, type752.getTree());
						if (this.state.backtracking == 0) {
							this.MethodReturn = type752.name;
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1810:9: vOID
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vOID_in_returntype10966);
						vOID753 = vOID();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vOID753.getTree());
						if (this.state.backtracking == 0) {
							this.MethodReturn = vOID753.getTree();
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "returntype"

	public static class membername_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "membername"
	// ../rsc/CSharp.g3:1814:1: membername returns [String name] : ( interfacetype dOT )? identifier ;
	public final CSharpParser.membername_return membername()
			throws RecognitionException {
		CSharpParser.membername_return retval =
			new CSharpParser.membername_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.interfacetype_return interfacetype754 = null;

		CSharpParser.dOT_return dOT755 = null;

		CSharpParser.identifier_return identifier756 = null;

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:1819:5: ( ( interfacetype dOT )? identifier )
			// ../rsc/CSharp.g3:1819:9: ( interfacetype dOT )? identifier
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:1819:9: ( interfacetype dOT )?
				int alt160 = 2;
				alt160 = this.dfa160.predict(this.input);
				switch (alt160) {
					case 1 :
					// ../rsc/CSharp.g3:1819:10: interfacetype dOT
						{
							pushFollow(FOLLOW_interfacetype_in_membername11001);
							interfacetype754 = interfacetype();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								this.adaptor.addChild(
									root_0,
									interfacetype754.getTree());
							pushFollow(FOLLOW_dOT_in_membername11003);
							dOT755 = dOT();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								this.adaptor.addChild(root_0, dOT755.getTree());
							if (this.state.backtracking == 0) {
								sb
									.append(
										(interfacetype754 != null ? interfacetype754.name
												: null))
									.append('.');
							}

						}
						break;

				}

				pushFollow(FOLLOW_identifier_in_membername11014);
				identifier756 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, identifier756.getTree());
				if (this.state.backtracking == 0) {
					sb.append((identifier756 != null ? identifier756.content
							: null));
					retval.name = sb.toString();
				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "membername"

	public static class methodbody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "methodbody"
	// ../rsc/CSharp.g3:1823:1: methodbody : ( block | sEMICOLON );
	public final CSharpParser.methodbody_return methodbody()
			throws RecognitionException {
		CSharpParser.methodbody_return retval =
			new CSharpParser.methodbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.block_return block757 = null;

		CSharpParser.sEMICOLON_return sEMICOLON758 = null;

		try {
			// ../rsc/CSharp.g3:1824:5: ( block | sEMICOLON )
			int alt161 = 2;
			int LA161_0 = this.input.LA(1);

			if ((LA161_0 == LBRACE)) {
				alt161 = 1;
			}
			else if ((LA161_0 == SEMICOLON)) {
				alt161 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 161, 0, this.input);

				throw nvae;
			}
			switch (alt161) {
				case 1 :
				// ../rsc/CSharp.g3:1824:9: block
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_block_in_methodbody11035);
						block757 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, block757.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1825:9: sEMICOLON
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEMICOLON_in_methodbody11045);
						sEMICOLON758 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEMICOLON758.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "methodbody"

	public static class formalparameterlist_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "formalparameterlist"
	// ../rsc/CSharp.g3:1828:1: formalparameterlist returns [String signature] : ( fixedparameters cOMMA parameterarray | fixedparameters | parameterarray );
	public final CSharpParser.formalparameterlist_return formalparameterlist()
			throws RecognitionException {
		CSharpParser.formalparameterlist_return retval =
			new CSharpParser.formalparameterlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.fixedparameters_return fixedparameters759 = null;

		CSharpParser.cOMMA_return cOMMA760 = null;

		CSharpParser.parameterarray_return parameterarray761 = null;

		CSharpParser.fixedparameters_return fixedparameters762 = null;

		CSharpParser.parameterarray_return parameterarray763 = null;

		try {
			// ../rsc/CSharp.g3:1829:5: ( fixedparameters cOMMA parameterarray | fixedparameters | parameterarray )
			int alt162 = 3;
			alt162 = this.dfa162.predict(this.input);
			switch (alt162) {
				case 1 :
				// ../rsc/CSharp.g3:1829:9: fixedparameters cOMMA parameterarray
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fixedparameters_in_formalparameterlist11068);
						fixedparameters759 = fixedparameters();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								fixedparameters759.getTree());
						pushFollow(FOLLOW_cOMMA_in_formalparameterlist11070);
						cOMMA760 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, cOMMA760.getTree());
						pushFollow(FOLLOW_parameterarray_in_formalparameterlist11072);
						parameterarray761 = parameterarray();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								parameterarray761.getTree());
						if (this.state.backtracking == 0) {
							retval.signature =
								(fixedparameters759 != null ? fixedparameters759.signature
										: null)
										+ ','
										+ (parameterarray761 != null ? parameterarray761.signature
												: null);
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1831:9: fixedparameters
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fixedparameters_in_formalparameterlist11089);
						fixedparameters762 = fixedparameters();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								fixedparameters762.getTree());
						if (this.state.backtracking == 0) {
							retval.signature =
								(fixedparameters762 != null ? fixedparameters762.signature
										: null);
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1833:9: parameterarray
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_parameterarray_in_formalparameterlist11106);
						parameterarray763 = parameterarray();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								parameterarray763.getTree());
						if (this.state.backtracking == 0) {
							retval.signature =
								(parameterarray763 != null ? parameterarray763.signature
										: null);
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "formalparameterlist"

	public static class fixedparameters_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fixedparameters"
	// ../rsc/CSharp.g3:1837:1: fixedparameters returns [String signature] : f1= fixedparameter ( cOMMA f2= fixedparameter )* ;
	public final CSharpParser.fixedparameters_return fixedparameters()
			throws RecognitionException {
		CSharpParser.fixedparameters_return retval =
			new CSharpParser.fixedparameters_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.fixedparameter_return f1 = null;

		CSharpParser.fixedparameter_return f2 = null;

		CSharpParser.cOMMA_return cOMMA764 = null;

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:1841:5: (f1= fixedparameter ( cOMMA f2= fixedparameter )* )
			// ../rsc/CSharp.g3:1841:9: f1= fixedparameter ( cOMMA f2= fixedparameter )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_fixedparameter_in_fixedparameters11144);
				f1 = fixedparameter();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, f1.getTree());
				if (this.state.backtracking == 0) {
					sb.append((f1 != null ? f1.signature : null));
				}
				// ../rsc/CSharp.g3:1842:6: ( cOMMA f2= fixedparameter )*
				loop163: do {
					int alt163 = 2;
					int LA163_0 = this.input.LA(1);

					if ((LA163_0 == COMMA)) {
						this.input.LA(2);

						if ((synpred415_CSharp())) {
							alt163 = 1;
						}

					}

					switch (alt163) {
						case 1 :
						// ../rsc/CSharp.g3:1842:7: cOMMA f2= fixedparameter
							{
								pushFollow(FOLLOW_cOMMA_in_fixedparameters11154);
								cOMMA764 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor
										.addChild(root_0, cOMMA764.getTree());
								pushFollow(FOLLOW_fixedparameter_in_fixedparameters11158);
								f2 = fixedparameter();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(root_0, f2.getTree());
								if (this.state.backtracking == 0) {
									sb.append(',').append(
										(f2 != null ? f2.signature : null));
								}

							}
							break;

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

				if (this.state.backtracking == 0) {
					retval.signature = sb.toString();
				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fixedparameters"

	public static class fixedparameter_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fixedparameter"
	// ../rsc/CSharp.g3:1846:1: fixedparameter returns [String signature] : ( attributes )? ( parametermodifier )? type identifier -> ^( Parameter ( attributes )? ( parametermodifier )? type identifier ) ;
	public final CSharpParser.fixedparameter_return fixedparameter()
			throws RecognitionException {
		CSharpParser.fixedparameter_return retval =
			new CSharpParser.fixedparameter_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes765 = null;

		CSharpParser.parametermodifier_return parametermodifier766 = null;

		CSharpParser.type_return type767 = null;

		CSharpParser.identifier_return identifier768 = null;

		RewriteRuleSubtreeStream stream_parametermodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule parametermodifier");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:1851:2: ( ( attributes )? ( parametermodifier )? type identifier -> ^( Parameter ( attributes )? ( parametermodifier )? type identifier ) )
			// ../rsc/CSharp.g3:1851:6: ( attributes )? ( parametermodifier )? type identifier
			{
				// ../rsc/CSharp.g3:1851:6: ( attributes )?
				int alt164 = 2;
				int LA164_0 = this.input.LA(1);

				if ((LA164_0 == LBRACKET)) {
					alt164 = 1;
				}
				switch (alt164) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_fixedparameter11195);
							attributes765 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes765.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1852:3: ( parametermodifier )?
				int alt165 = 2;
				int LA165_0 = this.input.LA(1);

				if ((LA165_0 == OUT || LA165_0 == REF)) {
					alt165 = 1;
				}
				switch (alt165) {
					case 1 :
					// ../rsc/CSharp.g3:1852:4: parametermodifier
						{
							pushFollow(FOLLOW_parametermodifier_in_fixedparameter11201);
							parametermodifier766 = parametermodifier();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_parametermodifier
									.add(parametermodifier766.getTree());
							if (this.state.backtracking == 0) {
								sb
									.append((parametermodifier766 != null ? parametermodifier766.content
											: null));
							}

						}
						break;

				}

				pushFollow(FOLLOW_type_in_fixedparameter11209);
				type767 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type767.getTree());
				pushFollow(FOLLOW_identifier_in_fixedparameter11211);
				identifier768 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier768.getTree());
				if (this.state.backtracking == 0) {

					sb.append((type767 != null ? type767.name : null));
					retval.signature = sb.toString();
				}

				// AST REWRITE
				// elements: type, parametermodifier, identifier, attributes
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1858:5: -> ^( Parameter ( attributes )? ( parametermodifier )? type identifier )
					{
						// ../rsc/CSharp.g3:1858:8: ^( Parameter ( attributes )? ( parametermodifier )? type identifier )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Parameter, "Parameter"), root_1);

							// ../rsc/CSharp.g3:1858:20: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:1858:32: ( parametermodifier )?
							if (stream_parametermodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_parametermodifier.nextTree());

							}
							stream_parametermodifier.reset();
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fixedparameter"

	public static class parametermodifier_return extends ParserRuleReturnScope {
		public String content;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "parametermodifier"
	// ../rsc/CSharp.g3:1861:1: parametermodifier returns [String content] : ( rEF | oUT );
	public final CSharpParser.parametermodifier_return parametermodifier()
			throws RecognitionException {
		CSharpParser.parametermodifier_return retval =
			new CSharpParser.parametermodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.rEF_return rEF769 = null;

		CSharpParser.oUT_return oUT770 = null;

		try {
			// ../rsc/CSharp.g3:1862:5: ( rEF | oUT )
			int alt166 = 2;
			int LA166_0 = this.input.LA(1);

			if ((LA166_0 == REF)) {
				alt166 = 1;
			}
			else if ((LA166_0 == OUT)) {
				alt166 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 166, 0, this.input);

				throw nvae;
			}
			switch (alt166) {
				case 1 :
				// ../rsc/CSharp.g3:1862:9: rEF
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_rEF_in_parametermodifier11256);
						rEF769 = rEF();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, rEF769.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "ref";
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1863:9: oUT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oUT_in_parametermodifier11268);
						oUT770 = oUT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oUT770.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "out";
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "parametermodifier"

	public static class parameterarray_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "parameterarray"
	// ../rsc/CSharp.g3:1866:1: parameterarray returns [String signature] : ( attributes )? pARAMS arraytype identifier -> ^( ParameterArray ( attributes )? pARAMS arraytype identifier ) ;
	public final CSharpParser.parameterarray_return parameterarray()
			throws RecognitionException {
		CSharpParser.parameterarray_return retval =
			new CSharpParser.parameterarray_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes771 = null;

		CSharpParser.pARAMS_return pARAMS772 = null;

		CSharpParser.arraytype_return arraytype773 = null;

		CSharpParser.identifier_return identifier774 = null;

		RewriteRuleSubtreeStream stream_arraytype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule arraytype");
		RewriteRuleSubtreeStream stream_pARAMS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule pARAMS");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:1867:5: ( ( attributes )? pARAMS arraytype identifier -> ^( ParameterArray ( attributes )? pARAMS arraytype identifier ) )
			// ../rsc/CSharp.g3:1867:9: ( attributes )? pARAMS arraytype identifier
			{
				// ../rsc/CSharp.g3:1867:9: ( attributes )?
				int alt167 = 2;
				int LA167_0 = this.input.LA(1);

				if ((LA167_0 == LBRACKET)) {
					alt167 = 1;
				}
				switch (alt167) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_parameterarray11293);
							attributes771 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes771.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_pARAMS_in_parameterarray11296);
				pARAMS772 = pARAMS();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_pARAMS.add(pARAMS772.getTree());
				pushFollow(FOLLOW_arraytype_in_parameterarray11298);
				arraytype773 = arraytype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_arraytype.add(arraytype773.getTree());
				pushFollow(FOLLOW_identifier_in_parameterarray11300);
				identifier774 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier774.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(arraytype773 != null ? arraytype773.signature : null);
				}

				// AST REWRITE
				// elements: identifier, attributes, arraytype, pARAMS
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1869:5: -> ^( ParameterArray ( attributes )? pARAMS arraytype identifier )
					{
						// ../rsc/CSharp.g3:1869:8: ^( ParameterArray ( attributes )? pARAMS arraytype identifier )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ParameterArray,
										"ParameterArray"),
									root_1);

							// ../rsc/CSharp.g3:1869:25: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							this.adaptor.addChild(root_1, stream_pARAMS.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_arraytype.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "parameterarray"

	public static class propertydeclaration_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "propertydeclaration"
	// ../rsc/CSharp.g3:1873:1: propertydeclaration returns [String name] : ( attributes )? ( propertymodifiers )? type membername lBRACE accessordeclarations rBRACE -> ^( Property ( attributes )? ( propertymodifiers )? type membername ^( AccessorDeclarations lBRACE accessordeclarations rBRACE ) ) ;
	public final CSharpParser.propertydeclaration_return propertydeclaration()
			throws RecognitionException {
		CSharpParser.propertydeclaration_return retval =
			new CSharpParser.propertydeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes775 = null;

		CSharpParser.propertymodifiers_return propertymodifiers776 = null;

		CSharpParser.type_return type777 = null;

		CSharpParser.membername_return membername778 = null;

		CSharpParser.lBRACE_return lBRACE779 = null;

		CSharpParser.accessordeclarations_return accessordeclarations780 = null;

		CSharpParser.rBRACE_return rBRACE781 = null;

		RewriteRuleSubtreeStream stream_accessordeclarations =
			new RewriteRuleSubtreeStream(this.adaptor, "rule accessordeclarations");
		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_propertymodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule propertymodifiers");
		RewriteRuleSubtreeStream stream_membername =
			new RewriteRuleSubtreeStream(this.adaptor, "rule membername");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:1877:5: ( ( attributes )? ( propertymodifiers )? type membername lBRACE accessordeclarations rBRACE -> ^( Property ( attributes )? ( propertymodifiers )? type membername ^( AccessorDeclarations lBRACE accessordeclarations rBRACE ) ) )
			// ../rsc/CSharp.g3:1877:9: ( attributes )? ( propertymodifiers )? type membername lBRACE accessordeclarations rBRACE
			{
				// ../rsc/CSharp.g3:1877:9: ( attributes )?
				int alt168 = 2;
				int LA168_0 = this.input.LA(1);

				if ((LA168_0 == LBRACKET)) {
					alt168 = 1;
				}
				switch (alt168) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_propertydeclaration11356);
							attributes775 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes775.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1877:21: ( propertymodifiers )?
				int alt169 = 2;
				int LA169_0 = this.input.LA(1);

				if ((LA169_0 == ABSTRACT || LA169_0 == EXTERN
						|| LA169_0 == INTERNAL || LA169_0 == NEW
						|| LA169_0 == OVERRIDE
						|| (LA169_0 >= PRIVATE && LA169_0 <= PUBLIC)
						|| LA169_0 == SEALED || LA169_0 == STATIC || LA169_0 == VIRTUAL)) {
					alt169 = 1;
				}
				switch (alt169) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: propertymodifiers
						{
							pushFollow(FOLLOW_propertymodifiers_in_propertydeclaration11359);
							propertymodifiers776 = propertymodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_propertymodifiers
									.add(propertymodifiers776.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_type_in_propertydeclaration11362);
				type777 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type777.getTree());
				pushFollow(FOLLOW_membername_in_propertydeclaration11364);
				membername778 = membername();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_membername.add(membername778.getTree());
				pushFollow(FOLLOW_lBRACE_in_propertydeclaration11366);
				lBRACE779 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE779.getTree());
				pushFollow(FOLLOW_accessordeclarations_in_propertydeclaration11368);
				accessordeclarations780 = accessordeclarations();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_accessordeclarations.add(accessordeclarations780
						.getTree());
				pushFollow(FOLLOW_rBRACE_in_propertydeclaration11370);
				rBRACE781 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE781.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(membername778 != null ? membername778.name : null);
				}

				// AST REWRITE
				// elements: attributes, propertymodifiers, type, lBRACE, rBRACE, accessordeclarations, membername
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1879:5: -> ^( Property ( attributes )? ( propertymodifiers )? type membername ^( AccessorDeclarations lBRACE accessordeclarations rBRACE ) )
					{
						// ../rsc/CSharp.g3:1879:8: ^( Property ( attributes )? ( propertymodifiers )? type membername ^( AccessorDeclarations lBRACE accessordeclarations rBRACE ) )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Property, "Property"), root_1);

							// ../rsc/CSharp.g3:1879:19: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:1879:31: ( propertymodifiers )?
							if (stream_propertymodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_propertymodifiers.nextTree());

							}
							stream_propertymodifiers.reset();
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_membername.nextTree());
							// ../rsc/CSharp.g3:1880:6: ^( AccessorDeclarations lBRACE accessordeclarations rBRACE )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											AccessorDeclarations,
											"AccessorDeclarations"),
										root_2);

								this.adaptor.addChild(
									root_2,
									stream_lBRACE.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_accessordeclarations.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_rBRACE.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "propertydeclaration"

	public static class propertymodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "propertymodifiers"
	// ../rsc/CSharp.g3:1884:1: propertymodifiers : ( propertymodifier )+ -> ^( Modifiers ( propertymodifier )+ ) ;
	public final CSharpParser.propertymodifiers_return propertymodifiers()
			throws RecognitionException {
		CSharpParser.propertymodifiers_return retval =
			new CSharpParser.propertymodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.propertymodifier_return propertymodifier782 = null;

		RewriteRuleSubtreeStream stream_propertymodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule propertymodifier");
		try {
			// ../rsc/CSharp.g3:1885:5: ( ( propertymodifier )+ -> ^( Modifiers ( propertymodifier )+ ) )
			// ../rsc/CSharp.g3:1885:9: ( propertymodifier )+
			{
				// ../rsc/CSharp.g3:1885:9: ( propertymodifier )+
				int cnt170 = 0;
				loop170: do {
					int alt170 = 2;
					int LA170_0 = this.input.LA(1);

					if ((LA170_0 == ABSTRACT || LA170_0 == EXTERN
							|| LA170_0 == INTERNAL || LA170_0 == NEW
							|| LA170_0 == OVERRIDE
							|| (LA170_0 >= PRIVATE && LA170_0 <= PUBLIC)
							|| LA170_0 == SEALED || LA170_0 == STATIC || LA170_0 == VIRTUAL)) {
						alt170 = 1;
					}

					switch (alt170) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: propertymodifier
							{
								pushFollow(FOLLOW_propertymodifier_in_propertymodifiers11434);
								propertymodifier782 = propertymodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_propertymodifier
										.add(propertymodifier782.getTree());

							}
							break;

						default :
							if (cnt170 >= 1)
								break loop170;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(170, this.input);
							throw eee;
					}
					cnt170++;
				}
				while (true);

				// AST REWRITE
				// elements: propertymodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1886:5: -> ^( Modifiers ( propertymodifier )+ )
					{
						// ../rsc/CSharp.g3:1886:8: ^( Modifiers ( propertymodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_propertymodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_propertymodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_propertymodifier.nextTree());

							}
							stream_propertymodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "propertymodifiers"

	public static class propertymodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "propertymodifier"
	// ../rsc/CSharp.g3:1889:1: propertymodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN );
	public final CSharpParser.propertymodifier_return propertymodifier()
			throws RecognitionException {
		CSharpParser.propertymodifier_return retval =
			new CSharpParser.propertymodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW783 = null;

		CSharpParser.pUBLIC_return pUBLIC784 = null;

		CSharpParser.pROTECTED_return pROTECTED785 = null;

		CSharpParser.iNTERNAL_return iNTERNAL786 = null;

		CSharpParser.pRIVATE_return pRIVATE787 = null;

		CSharpParser.sTATIC_return sTATIC788 = null;

		CSharpParser.vIRTUAL_return vIRTUAL789 = null;

		CSharpParser.sEALED_return sEALED790 = null;

		CSharpParser.oVERRIDE_return oVERRIDE791 = null;

		CSharpParser.aBSTRACT_return aBSTRACT792 = null;

		CSharpParser.eXTERN_return eXTERN793 = null;

		try {
			// ../rsc/CSharp.g3:1890:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN )
			int alt171 = 11;
			alt171 = this.dfa171.predict(this.input);
			switch (alt171) {
				case 1 :
				// ../rsc/CSharp.g3:1890:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_propertymodifier11467);
						nEW783 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW783.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1891:9: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_propertymodifier11477);
						pUBLIC784 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC784.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1892:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_propertymodifier11487);
						pROTECTED785 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED785.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1893:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_propertymodifier11497);
						iNTERNAL786 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL786.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1894:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_propertymodifier11507);
						pRIVATE787 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE787.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:1895:9: sTATIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTATIC_in_propertymodifier11517);
						sTATIC788 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTATIC788.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:1896:9: vIRTUAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vIRTUAL_in_propertymodifier11527);
						vIRTUAL789 = vIRTUAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vIRTUAL789.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:1897:9: sEALED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEALED_in_propertymodifier11537);
						sEALED790 = sEALED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEALED790.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:1898:9: oVERRIDE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oVERRIDE_in_propertymodifier11547);
						oVERRIDE791 = oVERRIDE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oVERRIDE791.getTree());

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:1899:9: aBSTRACT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aBSTRACT_in_propertymodifier11557);
						aBSTRACT792 = aBSTRACT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aBSTRACT792.getTree());

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:1900:9: eXTERN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXTERN_in_propertymodifier11567);
						eXTERN793 = eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXTERN793.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "propertymodifier"

	public static class accessordeclarations_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "accessordeclarations"
	// ../rsc/CSharp.g3:1903:1: accessordeclarations : ( getaccessordeclaration ( setaccessordeclaration )? | setaccessordeclaration ( getaccessordeclaration )? );
	public final CSharpParser.accessordeclarations_return accessordeclarations()
			throws RecognitionException {
		CSharpParser.accessordeclarations_return retval =
			new CSharpParser.accessordeclarations_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.getaccessordeclaration_return getaccessordeclaration794 =
			null;

		CSharpParser.setaccessordeclaration_return setaccessordeclaration795 =
			null;

		CSharpParser.setaccessordeclaration_return setaccessordeclaration796 =
			null;

		CSharpParser.getaccessordeclaration_return getaccessordeclaration797 =
			null;

		try {
			// ../rsc/CSharp.g3:1904:5: ( getaccessordeclaration ( setaccessordeclaration )? | setaccessordeclaration ( getaccessordeclaration )? )
			int alt174 = 2;
			switch (this.input.LA(1)) {
				case LBRACKET :
					{
						this.input.LA(2);

						if ((synpred434_CSharp())) {
							alt174 = 1;
						}
						else if ((true)) {
							alt174 = 2;
						}
					}
					break;
				case PROTECTED :
					{
						this.input.LA(2);

						if ((synpred434_CSharp())) {
							alt174 = 1;
						}
						else if ((true)) {
							alt174 = 2;
						}
					}
					break;
				case INTERNAL :
					{
						this.input.LA(2);

						if ((synpred434_CSharp())) {
							alt174 = 1;
						}
						else if ((true)) {
							alt174 = 2;
						}
					}
					break;
				case PRIVATE :
					{
						this.input.LA(2);

						if ((synpred434_CSharp())) {
							alt174 = 1;
						}
						else if ((true)) {
							alt174 = 2;
						}
					}
					break;
				case GET :
					{
						alt174 = 1;
					}
					break;
				case SET :
					{
						alt174 = 2;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 174, 0, this.input);

					throw nvae;
			}

			switch (alt174) {
				case 1 :
				// ../rsc/CSharp.g3:1904:9: getaccessordeclaration ( setaccessordeclaration )?
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_getaccessordeclaration_in_accessordeclarations11586);
						getaccessordeclaration794 = getaccessordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								getaccessordeclaration794.getTree());
						// ../rsc/CSharp.g3:1904:32: ( setaccessordeclaration )?
						int alt172 = 2;
						int LA172_0 = this.input.LA(1);

						if ((LA172_0 == LBRACKET || LA172_0 == INTERNAL
								|| (LA172_0 >= PRIVATE && LA172_0 <= PROTECTED) || LA172_0 == SET)) {
							alt172 = 1;
						}
						switch (alt172) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: setaccessordeclaration
								{
									pushFollow(FOLLOW_setaccessordeclaration_in_accessordeclarations11588);
									setaccessordeclaration795 =
										setaccessordeclaration();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										this.adaptor
											.addChild(
												root_0,
												setaccessordeclaration795
													.getTree());

								}
								break;

						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1905:9: setaccessordeclaration ( getaccessordeclaration )?
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_setaccessordeclaration_in_accessordeclarations11599);
						setaccessordeclaration796 = setaccessordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								setaccessordeclaration796.getTree());
						// ../rsc/CSharp.g3:1905:32: ( getaccessordeclaration )?
						int alt173 = 2;
						int LA173_0 = this.input.LA(1);

						if ((LA173_0 == LBRACKET || LA173_0 == INTERNAL
								|| (LA173_0 >= PRIVATE && LA173_0 <= PROTECTED) || LA173_0 == GET)) {
							alt173 = 1;
						}
						switch (alt173) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: getaccessordeclaration
								{
									pushFollow(FOLLOW_getaccessordeclaration_in_accessordeclarations11601);
									getaccessordeclaration797 =
										getaccessordeclaration();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										this.adaptor
											.addChild(
												root_0,
												getaccessordeclaration797
													.getTree());

								}
								break;

						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "accessordeclarations"

	public static class getaccessordeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "getaccessordeclaration"
	// ../rsc/CSharp.g3:1908:1: getaccessordeclaration : ( attributes )? ( accessormodifier )? gET accessorbody -> ^( GetAccessor ( attributes )? ( accessormodifier )? gET accessorbody ) ;
	public final CSharpParser.getaccessordeclaration_return getaccessordeclaration()
			throws RecognitionException {
		CSharpParser.getaccessordeclaration_return retval =
			new CSharpParser.getaccessordeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes798 = null;

		CSharpParser.accessormodifier_return accessormodifier799 = null;

		CSharpParser.gET_return gET800 = null;

		CSharpParser.accessorbody_return accessorbody801 = null;

		RewriteRuleSubtreeStream stream_accessorbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule accessorbody");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_gET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gET");
		RewriteRuleSubtreeStream stream_accessormodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule accessormodifier");
		try {
			// ../rsc/CSharp.g3:1909:5: ( ( attributes )? ( accessormodifier )? gET accessorbody -> ^( GetAccessor ( attributes )? ( accessormodifier )? gET accessorbody ) )
			// ../rsc/CSharp.g3:1909:9: ( attributes )? ( accessormodifier )? gET accessorbody
			{
				// ../rsc/CSharp.g3:1909:9: ( attributes )?
				int alt175 = 2;
				int LA175_0 = this.input.LA(1);

				if ((LA175_0 == LBRACKET)) {
					alt175 = 1;
				}
				switch (alt175) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_getaccessordeclaration11621);
							attributes798 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes798.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1909:21: ( accessormodifier )?
				int alt176 = 2;
				int LA176_0 = this.input.LA(1);

				if ((LA176_0 == INTERNAL || (LA176_0 >= PRIVATE && LA176_0 <= PROTECTED))) {
					alt176 = 1;
				}
				switch (alt176) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: accessormodifier
						{
							pushFollow(FOLLOW_accessormodifier_in_getaccessordeclaration11624);
							accessormodifier799 = accessormodifier();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_accessormodifier.add(accessormodifier799
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_gET_in_getaccessordeclaration11627);
				gET800 = gET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_gET.add(gET800.getTree());
				pushFollow(FOLLOW_accessorbody_in_getaccessordeclaration11629);
				accessorbody801 = accessorbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_accessorbody.add(accessorbody801.getTree());

				// AST REWRITE
				// elements: accessorbody, gET, accessormodifier, attributes
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1910:5: -> ^( GetAccessor ( attributes )? ( accessormodifier )? gET accessorbody )
					{
						// ../rsc/CSharp.g3:1910:8: ^( GetAccessor ( attributes )? ( accessormodifier )? gET accessorbody )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										GetAccessor,
										"GetAccessor"), root_1);

							// ../rsc/CSharp.g3:1910:22: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:1910:34: ( accessormodifier )?
							if (stream_accessormodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_accessormodifier.nextTree());

							}
							stream_accessormodifier.reset();
							this.adaptor.addChild(root_1, stream_gET.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_accessorbody.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "getaccessordeclaration"

	public static class setaccessordeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "setaccessordeclaration"
	// ../rsc/CSharp.g3:1913:1: setaccessordeclaration : ( attributes )? ( accessormodifier )? sET accessorbody -> ^( SetAccessor ( attributes )? ( accessormodifier )? sET accessorbody ) ;
	public final CSharpParser.setaccessordeclaration_return setaccessordeclaration()
			throws RecognitionException {
		CSharpParser.setaccessordeclaration_return retval =
			new CSharpParser.setaccessordeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes802 = null;

		CSharpParser.accessormodifier_return accessormodifier803 = null;

		CSharpParser.sET_return sET804 = null;

		CSharpParser.accessorbody_return accessorbody805 = null;

		RewriteRuleSubtreeStream stream_accessorbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule accessorbody");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_accessormodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule accessormodifier");
		RewriteRuleSubtreeStream stream_sET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sET");
		try {
			// ../rsc/CSharp.g3:1914:5: ( ( attributes )? ( accessormodifier )? sET accessorbody -> ^( SetAccessor ( attributes )? ( accessormodifier )? sET accessorbody ) )
			// ../rsc/CSharp.g3:1914:9: ( attributes )? ( accessormodifier )? sET accessorbody
			{
				// ../rsc/CSharp.g3:1914:9: ( attributes )?
				int alt177 = 2;
				int LA177_0 = this.input.LA(1);

				if ((LA177_0 == LBRACKET)) {
					alt177 = 1;
				}
				switch (alt177) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_setaccessordeclaration11668);
							attributes802 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes802.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1914:21: ( accessormodifier )?
				int alt178 = 2;
				int LA178_0 = this.input.LA(1);

				if ((LA178_0 == INTERNAL || (LA178_0 >= PRIVATE && LA178_0 <= PROTECTED))) {
					alt178 = 1;
				}
				switch (alt178) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: accessormodifier
						{
							pushFollow(FOLLOW_accessormodifier_in_setaccessordeclaration11671);
							accessormodifier803 = accessormodifier();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_accessormodifier.add(accessormodifier803
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_sET_in_setaccessordeclaration11674);
				sET804 = sET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sET.add(sET804.getTree());
				pushFollow(FOLLOW_accessorbody_in_setaccessordeclaration11676);
				accessorbody805 = accessorbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_accessorbody.add(accessorbody805.getTree());

				// AST REWRITE
				// elements: accessorbody, sET, accessormodifier, attributes
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1915:5: -> ^( SetAccessor ( attributes )? ( accessormodifier )? sET accessorbody )
					{
						// ../rsc/CSharp.g3:1915:8: ^( SetAccessor ( attributes )? ( accessormodifier )? sET accessorbody )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										SetAccessor,
										"SetAccessor"), root_1);

							// ../rsc/CSharp.g3:1915:22: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:1915:34: ( accessormodifier )?
							if (stream_accessormodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_accessormodifier.nextTree());

							}
							stream_accessormodifier.reset();
							this.adaptor.addChild(root_1, stream_sET.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_accessorbody.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "setaccessordeclaration"

	public static class accessormodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "accessormodifier"
	// ../rsc/CSharp.g3:1918:1: accessormodifier : ( pROTECTED -> ^( Modifiers pROTECTED ) | iNTERNAL -> ^( Modifiers iNTERNAL ) | pRIVATE -> ^( Modifiers pRIVATE ) | pROTECTED iNTERNAL -> ^( Modifiers pROTECTED iNTERNAL ) | iNTERNAL pROTECTED -> ^( Modifiers iNTERNAL pROTECTED ) );
	public final CSharpParser.accessormodifier_return accessormodifier()
			throws RecognitionException {
		CSharpParser.accessormodifier_return retval =
			new CSharpParser.accessormodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.pROTECTED_return pROTECTED806 = null;

		CSharpParser.iNTERNAL_return iNTERNAL807 = null;

		CSharpParser.pRIVATE_return pRIVATE808 = null;

		CSharpParser.pROTECTED_return pROTECTED809 = null;

		CSharpParser.iNTERNAL_return iNTERNAL810 = null;

		CSharpParser.iNTERNAL_return iNTERNAL811 = null;

		CSharpParser.pROTECTED_return pROTECTED812 = null;

		RewriteRuleSubtreeStream stream_pROTECTED =
			new RewriteRuleSubtreeStream(this.adaptor, "rule pROTECTED");
		RewriteRuleSubtreeStream stream_pRIVATE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule pRIVATE");
		RewriteRuleSubtreeStream stream_iNTERNAL =
			new RewriteRuleSubtreeStream(this.adaptor, "rule iNTERNAL");
		try {
			// ../rsc/CSharp.g3:1919:5: ( pROTECTED -> ^( Modifiers pROTECTED ) | iNTERNAL -> ^( Modifiers iNTERNAL ) | pRIVATE -> ^( Modifiers pRIVATE ) | pROTECTED iNTERNAL -> ^( Modifiers pROTECTED iNTERNAL ) | iNTERNAL pROTECTED -> ^( Modifiers iNTERNAL pROTECTED ) )
			int alt179 = 5;
			alt179 = this.dfa179.predict(this.input);
			switch (alt179) {
				case 1 :
				// ../rsc/CSharp.g3:1919:9: pROTECTED
					{
						pushFollow(FOLLOW_pROTECTED_in_accessormodifier11715);
						pROTECTED806 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_pROTECTED.add(pROTECTED806.getTree());

						// AST REWRITE
						// elements: pROTECTED
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1919:21: -> ^( Modifiers pROTECTED )
							{
								// ../rsc/CSharp.g3:1919:25: ^( Modifiers pROTECTED )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_pROTECTED.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1920:9: iNTERNAL
					{
						pushFollow(FOLLOW_iNTERNAL_in_accessormodifier11736);
						iNTERNAL807 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_iNTERNAL.add(iNTERNAL807.getTree());

						// AST REWRITE
						// elements: iNTERNAL
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1920:20: -> ^( Modifiers iNTERNAL )
							{
								// ../rsc/CSharp.g3:1920:24: ^( Modifiers iNTERNAL )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_iNTERNAL.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1921:9: pRIVATE
					{
						pushFollow(FOLLOW_pRIVATE_in_accessormodifier11757);
						pRIVATE808 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_pRIVATE.add(pRIVATE808.getTree());

						// AST REWRITE
						// elements: pRIVATE
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1921:20: -> ^( Modifiers pRIVATE )
							{
								// ../rsc/CSharp.g3:1921:24: ^( Modifiers pRIVATE )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_pRIVATE.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1922:9: pROTECTED iNTERNAL
					{
						pushFollow(FOLLOW_pROTECTED_in_accessormodifier11779);
						pROTECTED809 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_pROTECTED.add(pROTECTED809.getTree());
						pushFollow(FOLLOW_iNTERNAL_in_accessormodifier11781);
						iNTERNAL810 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_iNTERNAL.add(iNTERNAL810.getTree());

						// AST REWRITE
						// elements: iNTERNAL, pROTECTED
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1922:28: -> ^( Modifiers pROTECTED iNTERNAL )
							{
								// ../rsc/CSharp.g3:1922:32: ^( Modifiers pROTECTED iNTERNAL )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_pROTECTED.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_iNTERNAL.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1923:9: iNTERNAL pROTECTED
					{
						pushFollow(FOLLOW_iNTERNAL_in_accessormodifier11802);
						iNTERNAL811 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_iNTERNAL.add(iNTERNAL811.getTree());
						pushFollow(FOLLOW_pROTECTED_in_accessormodifier11804);
						pROTECTED812 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_pROTECTED.add(pROTECTED812.getTree());

						// AST REWRITE
						// elements: pROTECTED, iNTERNAL
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1923:28: -> ^( Modifiers iNTERNAL pROTECTED )
							{
								// ../rsc/CSharp.g3:1923:31: ^( Modifiers iNTERNAL pROTECTED )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_iNTERNAL.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_pROTECTED.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "accessormodifier"

	public static class accessorbody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "accessorbody"
	// ../rsc/CSharp.g3:1926:1: accessorbody : ( block | sEMICOLON );
	public final CSharpParser.accessorbody_return accessorbody()
			throws RecognitionException {
		CSharpParser.accessorbody_return retval =
			new CSharpParser.accessorbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.block_return block813 = null;

		CSharpParser.sEMICOLON_return sEMICOLON814 = null;

		try {
			// ../rsc/CSharp.g3:1927:5: ( block | sEMICOLON )
			int alt180 = 2;
			int LA180_0 = this.input.LA(1);

			if ((LA180_0 == LBRACE)) {
				alt180 = 1;
			}
			else if ((LA180_0 == SEMICOLON)) {
				alt180 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 180, 0, this.input);

				throw nvae;
			}
			switch (alt180) {
				case 1 :
				// ../rsc/CSharp.g3:1927:9: block
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_block_in_accessorbody11833);
						block813 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, block813.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1928:9: sEMICOLON
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEMICOLON_in_accessorbody11843);
						sEMICOLON814 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEMICOLON814.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "accessorbody"

	public static class eventdeclaration_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eventdeclaration"
	// ../rsc/CSharp.g3:1931:1: eventdeclaration returns [String name] : ( ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON -> ^( Event ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON ) | ( attributes )? ( eventmodifiers )? eVENT type membername lBRACE eventaccessordeclarations rBRACE -> ^( Event ( attributes )? ( eventmodifiers )? eVENT type membername ^( AccessorDeclarations lBRACE eventaccessordeclarations rBRACE ) ) );
	public final CSharpParser.eventdeclaration_return eventdeclaration()
			throws RecognitionException {
		CSharpParser.eventdeclaration_return retval =
			new CSharpParser.eventdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes815 = null;

		CSharpParser.eventmodifiers_return eventmodifiers816 = null;

		CSharpParser.eVENT_return eVENT817 = null;

		CSharpParser.type_return type818 = null;

		CSharpParser.variabledeclarators_return variabledeclarators819 = null;

		CSharpParser.sEMICOLON_return sEMICOLON820 = null;

		CSharpParser.attributes_return attributes821 = null;

		CSharpParser.eventmodifiers_return eventmodifiers822 = null;

		CSharpParser.eVENT_return eVENT823 = null;

		CSharpParser.type_return type824 = null;

		CSharpParser.membername_return membername825 = null;

		CSharpParser.lBRACE_return lBRACE826 = null;

		CSharpParser.eventaccessordeclarations_return eventaccessordeclarations827 =
			null;

		CSharpParser.rBRACE_return rBRACE828 = null;

		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_eventmodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eventmodifiers");
		RewriteRuleSubtreeStream stream_variabledeclarators =
			new RewriteRuleSubtreeStream(this.adaptor, "rule variabledeclarators");
		RewriteRuleSubtreeStream stream_eventaccessordeclarations =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule eventaccessordeclarations");
		RewriteRuleSubtreeStream stream_membername =
			new RewriteRuleSubtreeStream(this.adaptor, "rule membername");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		RewriteRuleSubtreeStream stream_eVENT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eVENT");
		try {
			// ../rsc/CSharp.g3:1935:5: ( ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON -> ^( Event ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON ) | ( attributes )? ( eventmodifiers )? eVENT type membername lBRACE eventaccessordeclarations rBRACE -> ^( Event ( attributes )? ( eventmodifiers )? eVENT type membername ^( AccessorDeclarations lBRACE eventaccessordeclarations rBRACE ) ) )
			int alt185 = 2;
			alt185 = this.dfa185.predict(this.input);
			switch (alt185) {
				case 1 :
				// ../rsc/CSharp.g3:1935:9: ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON
					{
						// ../rsc/CSharp.g3:1935:9: ( attributes )?
						int alt181 = 2;
						int LA181_0 = this.input.LA(1);

						if ((LA181_0 == LBRACKET)) {
							alt181 = 1;
						}
						switch (alt181) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: attributes
								{
									pushFollow(FOLLOW_attributes_in_eventdeclaration11871);
									attributes815 = attributes();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_attributes.add(attributes815
											.getTree());

								}
								break;

						}

						// ../rsc/CSharp.g3:1935:21: ( eventmodifiers )?
						int alt182 = 2;
						int LA182_0 = this.input.LA(1);

						if ((LA182_0 == ABSTRACT || LA182_0 == EXTERN
								|| LA182_0 == INTERNAL || LA182_0 == NEW
								|| LA182_0 == OVERRIDE
								|| (LA182_0 >= PRIVATE && LA182_0 <= PUBLIC)
								|| LA182_0 == SEALED || LA182_0 == STATIC || LA182_0 == VIRTUAL)) {
							alt182 = 1;
						}
						switch (alt182) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: eventmodifiers
								{
									pushFollow(FOLLOW_eventmodifiers_in_eventdeclaration11874);
									eventmodifiers816 = eventmodifiers();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_eventmodifiers
											.add(eventmodifiers816.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_eVENT_in_eventdeclaration11877);
						eVENT817 = eVENT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_eVENT.add(eVENT817.getTree());
						pushFollow(FOLLOW_type_in_eventdeclaration11879);
						type818 = type();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_type.add(type818.getTree());
						pushFollow(FOLLOW_variabledeclarators_in_eventdeclaration11881);
						variabledeclarators819 = variabledeclarators();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_variabledeclarators
								.add(variabledeclarators819.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_eventdeclaration11883);
						sEMICOLON820 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON820.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(variabledeclarators819 != null ? variabledeclarators819.name
										: null);
						}

						// AST REWRITE
						// elements: eVENT, eventmodifiers, attributes, variabledeclarators, sEMICOLON, type
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1937:5: -> ^( Event ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON )
							{
								// ../rsc/CSharp.g3:1937:8: ^( Event ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Event,
												"Event"),
											root_1);

									// ../rsc/CSharp.g3:1937:16: ( attributes )?
									if (stream_attributes.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_attributes.nextTree());

									}
									stream_attributes.reset();
									// ../rsc/CSharp.g3:1937:28: ( eventmodifiers )?
									if (stream_eventmodifiers.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_eventmodifiers.nextTree());

									}
									stream_eventmodifiers.reset();
									this.adaptor.addChild(
										root_1,
										stream_eVENT.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_type.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_variabledeclarators.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1938:9: ( attributes )? ( eventmodifiers )? eVENT type membername lBRACE eventaccessordeclarations rBRACE
					{
						// ../rsc/CSharp.g3:1938:9: ( attributes )?
						int alt183 = 2;
						int LA183_0 = this.input.LA(1);

						if ((LA183_0 == LBRACKET)) {
							alt183 = 1;
						}
						switch (alt183) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: attributes
								{
									pushFollow(FOLLOW_attributes_in_eventdeclaration11924);
									attributes821 = attributes();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_attributes.add(attributes821
											.getTree());

								}
								break;

						}

						// ../rsc/CSharp.g3:1938:21: ( eventmodifiers )?
						int alt184 = 2;
						int LA184_0 = this.input.LA(1);

						if ((LA184_0 == ABSTRACT || LA184_0 == EXTERN
								|| LA184_0 == INTERNAL || LA184_0 == NEW
								|| LA184_0 == OVERRIDE
								|| (LA184_0 >= PRIVATE && LA184_0 <= PUBLIC)
								|| LA184_0 == SEALED || LA184_0 == STATIC || LA184_0 == VIRTUAL)) {
							alt184 = 1;
						}
						switch (alt184) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: eventmodifiers
								{
									pushFollow(FOLLOW_eventmodifiers_in_eventdeclaration11927);
									eventmodifiers822 = eventmodifiers();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_eventmodifiers
											.add(eventmodifiers822.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_eVENT_in_eventdeclaration11930);
						eVENT823 = eVENT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_eVENT.add(eVENT823.getTree());
						pushFollow(FOLLOW_type_in_eventdeclaration11932);
						type824 = type();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_type.add(type824.getTree());
						pushFollow(FOLLOW_membername_in_eventdeclaration11934);
						membername825 = membername();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_membername.add(membername825.getTree());
						pushFollow(FOLLOW_lBRACE_in_eventdeclaration11936);
						lBRACE826 = lBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACE.add(lBRACE826.getTree());
						pushFollow(FOLLOW_eventaccessordeclarations_in_eventdeclaration11938);
						eventaccessordeclarations827 =
							eventaccessordeclarations();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_eventaccessordeclarations
								.add(eventaccessordeclarations827.getTree());
						pushFollow(FOLLOW_rBRACE_in_eventdeclaration11940);
						rBRACE828 = rBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACE.add(rBRACE828.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(membername825 != null ? membername825.name
										: null);
						}

						// AST REWRITE
						// elements: rBRACE, eVENT, eventmodifiers, attributes, lBRACE, eventaccessordeclarations, membername, type
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 1940:5: -> ^( Event ( attributes )? ( eventmodifiers )? eVENT type membername ^( AccessorDeclarations lBRACE eventaccessordeclarations rBRACE ) )
							{
								// ../rsc/CSharp.g3:1940:8: ^( Event ( attributes )? ( eventmodifiers )? eVENT type membername ^( AccessorDeclarations lBRACE eventaccessordeclarations rBRACE ) )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Event,
												"Event"),
											root_1);

									// ../rsc/CSharp.g3:1940:16: ( attributes )?
									if (stream_attributes.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_attributes.nextTree());

									}
									stream_attributes.reset();
									// ../rsc/CSharp.g3:1940:28: ( eventmodifiers )?
									if (stream_eventmodifiers.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_eventmodifiers.nextTree());

									}
									stream_eventmodifiers.reset();
									this.adaptor.addChild(
										root_1,
										stream_eVENT.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_type.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_membername.nextTree());
									// ../rsc/CSharp.g3:1941:6: ^( AccessorDeclarations lBRACE eventaccessordeclarations rBRACE )
									{
										Object root_2 = (Object) this.adaptor.nil();
										root_2 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													AccessorDeclarations,
													"AccessorDeclarations"),
												root_2);

										this.adaptor.addChild(
											root_2,
											stream_lBRACE.nextTree());
										this.adaptor.addChild(
											root_2,
											stream_eventaccessordeclarations
												.nextTree());
										this.adaptor.addChild(
											root_2,
											stream_rBRACE.nextTree());

										this.adaptor.addChild(root_1, root_2);
									}

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eventdeclaration"

	public static class eventmodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eventmodifiers"
	// ../rsc/CSharp.g3:1944:1: eventmodifiers : ( eventmodifier )+ -> ^( Modifiers ( eventmodifier )+ ) ;
	public final CSharpParser.eventmodifiers_return eventmodifiers()
			throws RecognitionException {
		CSharpParser.eventmodifiers_return retval =
			new CSharpParser.eventmodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.eventmodifier_return eventmodifier829 = null;

		RewriteRuleSubtreeStream stream_eventmodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eventmodifier");
		try {
			// ../rsc/CSharp.g3:1945:5: ( ( eventmodifier )+ -> ^( Modifiers ( eventmodifier )+ ) )
			// ../rsc/CSharp.g3:1945:9: ( eventmodifier )+
			{
				// ../rsc/CSharp.g3:1945:9: ( eventmodifier )+
				int cnt186 = 0;
				loop186: do {
					int alt186 = 2;
					int LA186_0 = this.input.LA(1);

					if ((LA186_0 == ABSTRACT || LA186_0 == EXTERN
							|| LA186_0 == INTERNAL || LA186_0 == NEW
							|| LA186_0 == OVERRIDE
							|| (LA186_0 >= PRIVATE && LA186_0 <= PUBLIC)
							|| LA186_0 == SEALED || LA186_0 == STATIC || LA186_0 == VIRTUAL)) {
						alt186 = 1;
					}

					switch (alt186) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: eventmodifier
							{
								pushFollow(FOLLOW_eventmodifier_in_eventmodifiers12004);
								eventmodifier829 = eventmodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_eventmodifier.add(eventmodifier829
										.getTree());

							}
							break;

						default :
							if (cnt186 >= 1)
								break loop186;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(186, this.input);
							throw eee;
					}
					cnt186++;
				}
				while (true);

				// AST REWRITE
				// elements: eventmodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1946:5: -> ^( Modifiers ( eventmodifier )+ )
					{
						// ../rsc/CSharp.g3:1946:8: ^( Modifiers ( eventmodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_eventmodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_eventmodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_eventmodifier.nextTree());

							}
							stream_eventmodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eventmodifiers"

	public static class eventmodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eventmodifier"
	// ../rsc/CSharp.g3:1949:1: eventmodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN );
	public final CSharpParser.eventmodifier_return eventmodifier()
			throws RecognitionException {
		CSharpParser.eventmodifier_return retval =
			new CSharpParser.eventmodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW830 = null;

		CSharpParser.pUBLIC_return pUBLIC831 = null;

		CSharpParser.pROTECTED_return pROTECTED832 = null;

		CSharpParser.iNTERNAL_return iNTERNAL833 = null;

		CSharpParser.pRIVATE_return pRIVATE834 = null;

		CSharpParser.sTATIC_return sTATIC835 = null;

		CSharpParser.vIRTUAL_return vIRTUAL836 = null;

		CSharpParser.sEALED_return sEALED837 = null;

		CSharpParser.oVERRIDE_return oVERRIDE838 = null;

		CSharpParser.aBSTRACT_return aBSTRACT839 = null;

		CSharpParser.eXTERN_return eXTERN840 = null;

		try {
			// ../rsc/CSharp.g3:1950:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN )
			int alt187 = 11;
			alt187 = this.dfa187.predict(this.input);
			switch (alt187) {
				case 1 :
				// ../rsc/CSharp.g3:1950:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_eventmodifier12037);
						nEW830 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW830.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1951:9: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_eventmodifier12047);
						pUBLIC831 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC831.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1952:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_eventmodifier12057);
						pROTECTED832 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED832.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1953:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_eventmodifier12067);
						iNTERNAL833 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL833.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:1954:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_eventmodifier12077);
						pRIVATE834 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE834.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:1955:9: sTATIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTATIC_in_eventmodifier12087);
						sTATIC835 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTATIC835.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:1956:9: vIRTUAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vIRTUAL_in_eventmodifier12097);
						vIRTUAL836 = vIRTUAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vIRTUAL836.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:1957:9: sEALED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEALED_in_eventmodifier12107);
						sEALED837 = sEALED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEALED837.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:1958:9: oVERRIDE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oVERRIDE_in_eventmodifier12117);
						oVERRIDE838 = oVERRIDE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oVERRIDE838.getTree());

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:1959:9: aBSTRACT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aBSTRACT_in_eventmodifier12127);
						aBSTRACT839 = aBSTRACT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aBSTRACT839.getTree());

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:1960:9: eXTERN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXTERN_in_eventmodifier12137);
						eXTERN840 = eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXTERN840.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eventmodifier"

	public static class eventaccessordeclarations_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eventaccessordeclarations"
	// ../rsc/CSharp.g3:1965:1: eventaccessordeclarations : ( addaccessordeclaration removeaccessordeclaration | removeaccessordeclaration addaccessordeclaration );
	public final CSharpParser.eventaccessordeclarations_return eventaccessordeclarations()
			throws RecognitionException {
		CSharpParser.eventaccessordeclarations_return retval =
			new CSharpParser.eventaccessordeclarations_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.addaccessordeclaration_return addaccessordeclaration841 =
			null;

		CSharpParser.removeaccessordeclaration_return removeaccessordeclaration842 =
			null;

		CSharpParser.removeaccessordeclaration_return removeaccessordeclaration843 =
			null;

		CSharpParser.addaccessordeclaration_return addaccessordeclaration844 =
			null;

		try {
			// ../rsc/CSharp.g3:1966:5: ( addaccessordeclaration removeaccessordeclaration | removeaccessordeclaration addaccessordeclaration )
			int alt188 = 2;
			switch (this.input.LA(1)) {
				case LBRACKET :
					{
						this.input.LA(2);

						if ((synpred461_CSharp())) {
							alt188 = 1;
						}
						else if ((true)) {
							alt188 = 2;
						}
					}
					break;
				case ADD :
					{
						alt188 = 1;
					}
					break;
				case REMOVE :
					{
						alt188 = 2;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 188, 0, this.input);

					throw nvae;
			}

			switch (alt188) {
				case 1 :
				// ../rsc/CSharp.g3:1966:9: addaccessordeclaration removeaccessordeclaration
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_addaccessordeclaration_in_eventaccessordeclarations12158);
						addaccessordeclaration841 = addaccessordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								addaccessordeclaration841.getTree());
						pushFollow(FOLLOW_removeaccessordeclaration_in_eventaccessordeclarations12160);
						removeaccessordeclaration842 =
							removeaccessordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								removeaccessordeclaration842.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1967:9: removeaccessordeclaration addaccessordeclaration
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_removeaccessordeclaration_in_eventaccessordeclarations12170);
						removeaccessordeclaration843 =
							removeaccessordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								removeaccessordeclaration843.getTree());
						pushFollow(FOLLOW_addaccessordeclaration_in_eventaccessordeclarations12172);
						addaccessordeclaration844 = addaccessordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								addaccessordeclaration844.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eventaccessordeclarations"

	public static class addaccessordeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "addaccessordeclaration"
	// ../rsc/CSharp.g3:1970:1: addaccessordeclaration : ( attributes )? aDD block -> ^( AddAccessor ( attributes )? aDD block ) ;
	public final CSharpParser.addaccessordeclaration_return addaccessordeclaration()
			throws RecognitionException {
		CSharpParser.addaccessordeclaration_return retval =
			new CSharpParser.addaccessordeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes845 = null;

		CSharpParser.aDD_return aDD846 = null;

		CSharpParser.block_return block847 = null;

		RewriteRuleSubtreeStream stream_aDD =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aDD");
		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		try {
			// ../rsc/CSharp.g3:1971:5: ( ( attributes )? aDD block -> ^( AddAccessor ( attributes )? aDD block ) )
			// ../rsc/CSharp.g3:1971:9: ( attributes )? aDD block
			{
				// ../rsc/CSharp.g3:1971:9: ( attributes )?
				int alt189 = 2;
				int LA189_0 = this.input.LA(1);

				if ((LA189_0 == LBRACKET)) {
					alt189 = 1;
				}
				switch (alt189) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_addaccessordeclaration12191);
							attributes845 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes845.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_aDD_in_addaccessordeclaration12194);
				aDD846 = aDD();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_aDD.add(aDD846.getTree());
				pushFollow(FOLLOW_block_in_addaccessordeclaration12196);
				block847 = block();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_block.add(block847.getTree());

				// AST REWRITE
				// elements: attributes, block, aDD
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1972:5: -> ^( AddAccessor ( attributes )? aDD block )
					{
						// ../rsc/CSharp.g3:1972:8: ^( AddAccessor ( attributes )? aDD block )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										AddAccessor,
										"AddAccessor"), root_1);

							// ../rsc/CSharp.g3:1972:22: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							this.adaptor.addChild(root_1, stream_aDD.nextTree());
							this.adaptor.addChild(root_1, stream_block.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "addaccessordeclaration"

	public static class removeaccessordeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "removeaccessordeclaration"
	// ../rsc/CSharp.g3:1975:1: removeaccessordeclaration : ( attributes )? rEMOVE block -> ^( RemoveAccessor ( attributes )? rEMOVE block ) ;
	public final CSharpParser.removeaccessordeclaration_return removeaccessordeclaration()
			throws RecognitionException {
		CSharpParser.removeaccessordeclaration_return retval =
			new CSharpParser.removeaccessordeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes848 = null;

		CSharpParser.rEMOVE_return rEMOVE849 = null;

		CSharpParser.block_return block850 = null;

		RewriteRuleSubtreeStream stream_block =
			new RewriteRuleSubtreeStream(this.adaptor, "rule block");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_rEMOVE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rEMOVE");
		try {
			// ../rsc/CSharp.g3:1976:5: ( ( attributes )? rEMOVE block -> ^( RemoveAccessor ( attributes )? rEMOVE block ) )
			// ../rsc/CSharp.g3:1976:9: ( attributes )? rEMOVE block
			{
				// ../rsc/CSharp.g3:1976:9: ( attributes )?
				int alt190 = 2;
				int LA190_0 = this.input.LA(1);

				if ((LA190_0 == LBRACKET)) {
					alt190 = 1;
				}
				switch (alt190) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_removeaccessordeclaration12232);
							attributes848 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes848.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rEMOVE_in_removeaccessordeclaration12235);
				rEMOVE849 = rEMOVE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rEMOVE.add(rEMOVE849.getTree());
				pushFollow(FOLLOW_block_in_removeaccessordeclaration12237);
				block850 = block();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_block.add(block850.getTree());

				// AST REWRITE
				// elements: rEMOVE, block, attributes
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1977:5: -> ^( RemoveAccessor ( attributes )? rEMOVE block )
					{
						// ../rsc/CSharp.g3:1977:8: ^( RemoveAccessor ( attributes )? rEMOVE block )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										RemoveAccessor,
										"RemoveAccessor"),
									root_1);

							// ../rsc/CSharp.g3:1977:25: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							this.adaptor.addChild(root_1, stream_rEMOVE.nextTree());
							this.adaptor.addChild(root_1, stream_block.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "removeaccessordeclaration"

	public static class indexerdeclaration_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "indexerdeclaration"
	// ../rsc/CSharp.g3:1980:1: indexerdeclaration returns [String signature] : ( attributes )? ( indexermodifiers )? indexerdeclarator lBRACE accessordeclarations rBRACE -> ^( Indexer ( attributes )? ( indexermodifiers )? indexerdeclarator ^( AccessorDeclarations lBRACE accessordeclarations rBRACE ) ) ;
	public final CSharpParser.indexerdeclaration_return indexerdeclaration()
			throws RecognitionException {
		CSharpParser.indexerdeclaration_return retval =
			new CSharpParser.indexerdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes851 = null;

		CSharpParser.indexermodifiers_return indexermodifiers852 = null;

		CSharpParser.indexerdeclarator_return indexerdeclarator853 = null;

		CSharpParser.lBRACE_return lBRACE854 = null;

		CSharpParser.accessordeclarations_return accessordeclarations855 = null;

		CSharpParser.rBRACE_return rBRACE856 = null;

		RewriteRuleSubtreeStream stream_accessordeclarations =
			new RewriteRuleSubtreeStream(this.adaptor, "rule accessordeclarations");
		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_indexerdeclarator =
			new RewriteRuleSubtreeStream(this.adaptor, "rule indexerdeclarator");
		RewriteRuleSubtreeStream stream_indexermodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule indexermodifiers");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:1984:5: ( ( attributes )? ( indexermodifiers )? indexerdeclarator lBRACE accessordeclarations rBRACE -> ^( Indexer ( attributes )? ( indexermodifiers )? indexerdeclarator ^( AccessorDeclarations lBRACE accessordeclarations rBRACE ) ) )
			// ../rsc/CSharp.g3:1984:9: ( attributes )? ( indexermodifiers )? indexerdeclarator lBRACE accessordeclarations rBRACE
			{
				// ../rsc/CSharp.g3:1984:9: ( attributes )?
				int alt191 = 2;
				int LA191_0 = this.input.LA(1);

				if ((LA191_0 == LBRACKET)) {
					alt191 = 1;
				}
				switch (alt191) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_indexerdeclaration12282);
							attributes851 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes851.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:1984:21: ( indexermodifiers )?
				int alt192 = 2;
				int LA192_0 = this.input.LA(1);

				if ((LA192_0 == ABSTRACT || LA192_0 == EXTERN
						|| LA192_0 == INTERNAL || LA192_0 == NEW
						|| LA192_0 == OVERRIDE
						|| (LA192_0 >= PRIVATE && LA192_0 <= PUBLIC)
						|| LA192_0 == SEALED || LA192_0 == VIRTUAL)) {
					alt192 = 1;
				}
				switch (alt192) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: indexermodifiers
						{
							pushFollow(FOLLOW_indexermodifiers_in_indexerdeclaration12285);
							indexermodifiers852 = indexermodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_indexermodifiers.add(indexermodifiers852
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_indexerdeclarator_in_indexerdeclaration12288);
				indexerdeclarator853 = indexerdeclarator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_indexerdeclarator
						.add(indexerdeclarator853.getTree());
				pushFollow(FOLLOW_lBRACE_in_indexerdeclaration12290);
				lBRACE854 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE854.getTree());
				pushFollow(FOLLOW_accessordeclarations_in_indexerdeclaration12292);
				accessordeclarations855 = accessordeclarations();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_accessordeclarations.add(accessordeclarations855
						.getTree());
				pushFollow(FOLLOW_rBRACE_in_indexerdeclaration12294);
				rBRACE856 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE856.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(indexerdeclarator853 != null ? indexerdeclarator853.signature
								: null);
				}

				// AST REWRITE
				// elements: indexerdeclarator, attributes, rBRACE, accessordeclarations, lBRACE, indexermodifiers
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1986:5: -> ^( Indexer ( attributes )? ( indexermodifiers )? indexerdeclarator ^( AccessorDeclarations lBRACE accessordeclarations rBRACE ) )
					{
						// ../rsc/CSharp.g3:1986:8: ^( Indexer ( attributes )? ( indexermodifiers )? indexerdeclarator ^( AccessorDeclarations lBRACE accessordeclarations rBRACE ) )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										Indexer,
										"Indexer"), root_1);

							// ../rsc/CSharp.g3:1986:18: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:1986:30: ( indexermodifiers )?
							if (stream_indexermodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_indexermodifiers.nextTree());

							}
							stream_indexermodifiers.reset();
							this.adaptor.addChild(
								root_1,
								stream_indexerdeclarator.nextTree());
							// ../rsc/CSharp.g3:1987:6: ^( AccessorDeclarations lBRACE accessordeclarations rBRACE )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											AccessorDeclarations,
											"AccessorDeclarations"),
										root_2);

								this.adaptor.addChild(
									root_2,
									stream_lBRACE.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_accessordeclarations.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_rBRACE.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.signature);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "indexerdeclaration"

	public static class indexermodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "indexermodifiers"
	// ../rsc/CSharp.g3:1990:1: indexermodifiers : ( indexermodifier )+ -> ^( Modifiers ( indexermodifier )+ ) ;
	public final CSharpParser.indexermodifiers_return indexermodifiers()
			throws RecognitionException {
		CSharpParser.indexermodifiers_return retval =
			new CSharpParser.indexermodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.indexermodifier_return indexermodifier857 = null;

		RewriteRuleSubtreeStream stream_indexermodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule indexermodifier");
		try {
			// ../rsc/CSharp.g3:1991:5: ( ( indexermodifier )+ -> ^( Modifiers ( indexermodifier )+ ) )
			// ../rsc/CSharp.g3:1991:9: ( indexermodifier )+
			{
				// ../rsc/CSharp.g3:1991:9: ( indexermodifier )+
				int cnt193 = 0;
				loop193: do {
					int alt193 = 2;
					int LA193_0 = this.input.LA(1);

					if ((LA193_0 == ABSTRACT || LA193_0 == EXTERN
							|| LA193_0 == INTERNAL || LA193_0 == NEW
							|| LA193_0 == OVERRIDE
							|| (LA193_0 >= PRIVATE && LA193_0 <= PUBLIC)
							|| LA193_0 == SEALED || LA193_0 == VIRTUAL)) {
						alt193 = 1;
					}

					switch (alt193) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: indexermodifier
							{
								pushFollow(FOLLOW_indexermodifier_in_indexermodifiers12352);
								indexermodifier857 = indexermodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_indexermodifier
										.add(indexermodifier857.getTree());

							}
							break;

						default :
							if (cnt193 >= 1)
								break loop193;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(193, this.input);
							throw eee;
					}
					cnt193++;
				}
				while (true);

				// AST REWRITE
				// elements: indexermodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 1992:2: -> ^( Modifiers ( indexermodifier )+ )
					{
						// ../rsc/CSharp.g3:1992:6: ^( Modifiers ( indexermodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_indexermodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_indexermodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_indexermodifier.nextTree());

							}
							stream_indexermodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "indexermodifiers"

	public static class indexermodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "indexermodifier"
	// ../rsc/CSharp.g3:1995:1: indexermodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN );
	public final CSharpParser.indexermodifier_return indexermodifier()
			throws RecognitionException {
		CSharpParser.indexermodifier_return retval =
			new CSharpParser.indexermodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW858 = null;

		CSharpParser.pUBLIC_return pUBLIC859 = null;

		CSharpParser.pROTECTED_return pROTECTED860 = null;

		CSharpParser.iNTERNAL_return iNTERNAL861 = null;

		CSharpParser.pRIVATE_return pRIVATE862 = null;

		CSharpParser.vIRTUAL_return vIRTUAL863 = null;

		CSharpParser.sEALED_return sEALED864 = null;

		CSharpParser.oVERRIDE_return oVERRIDE865 = null;

		CSharpParser.aBSTRACT_return aBSTRACT866 = null;

		CSharpParser.eXTERN_return eXTERN867 = null;

		try {
			// ../rsc/CSharp.g3:1996:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN )
			int alt194 = 10;
			alt194 = this.dfa194.predict(this.input);
			switch (alt194) {
				case 1 :
				// ../rsc/CSharp.g3:1996:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_indexermodifier12383);
						nEW858 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW858.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:1997:9: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_indexermodifier12393);
						pUBLIC859 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC859.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:1998:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_indexermodifier12403);
						pROTECTED860 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED860.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:1999:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_indexermodifier12413);
						iNTERNAL861 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL861.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2000:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_indexermodifier12423);
						pRIVATE862 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE862.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:2001:9: vIRTUAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_vIRTUAL_in_indexermodifier12433);
						vIRTUAL863 = vIRTUAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, vIRTUAL863.getTree());

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:2002:9: sEALED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEALED_in_indexermodifier12443);
						sEALED864 = sEALED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEALED864.getTree());

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:2003:9: oVERRIDE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_oVERRIDE_in_indexermodifier12453);
						oVERRIDE865 = oVERRIDE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, oVERRIDE865.getTree());

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:2004:9: aBSTRACT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aBSTRACT_in_indexermodifier12463);
						aBSTRACT866 = aBSTRACT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aBSTRACT866.getTree());

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:2005:9: eXTERN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXTERN_in_indexermodifier12473);
						eXTERN867 = eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXTERN867.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "indexermodifier"

	public static class indexerdeclarator_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "indexerdeclarator"
	// ../rsc/CSharp.g3:2008:1: indexerdeclarator returns [String signature] : type ( interfacetype dOT )? tHIS lBRACKET formalparameterlist rBRACKET -> type ( interfacetype dOT )? tHIS ^( ParameterList lBRACKET ( formalparameterlist )? rBRACKET ) ;
	public final CSharpParser.indexerdeclarator_return indexerdeclarator()
			throws RecognitionException {
		CSharpParser.indexerdeclarator_return retval =
			new CSharpParser.indexerdeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.type_return type868 = null;

		CSharpParser.interfacetype_return interfacetype869 = null;

		CSharpParser.dOT_return dOT870 = null;

		CSharpParser.tHIS_return tHIS871 = null;

		CSharpParser.lBRACKET_return lBRACKET872 = null;

		CSharpParser.formalparameterlist_return formalparameterlist873 = null;

		CSharpParser.rBRACKET_return rBRACKET874 = null;

		RewriteRuleSubtreeStream stream_tHIS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule tHIS");
		RewriteRuleSubtreeStream stream_interfacetype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfacetype");
		RewriteRuleSubtreeStream stream_lBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACKET");
		RewriteRuleSubtreeStream stream_dOT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dOT");
		RewriteRuleSubtreeStream stream_formalparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule formalparameterlist");
		RewriteRuleSubtreeStream stream_rBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACKET");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		try {
			// ../rsc/CSharp.g3:2027:5: ( type ( interfacetype dOT )? tHIS lBRACKET formalparameterlist rBRACKET -> type ( interfacetype dOT )? tHIS ^( ParameterList lBRACKET ( formalparameterlist )? rBRACKET ) )
			// ../rsc/CSharp.g3:2027:9: type ( interfacetype dOT )? tHIS lBRACKET formalparameterlist rBRACKET
			{
				pushFollow(FOLLOW_type_in_indexerdeclarator12501);
				type868 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type868.getTree());
				// ../rsc/CSharp.g3:2027:14: ( interfacetype dOT )?
				int alt195 = 2;
				int LA195_0 = this.input.LA(1);

				if (((LA195_0 >= ADD && LA195_0 <= Ident))) {
					alt195 = 1;
				}
				switch (alt195) {
					case 1 :
					// ../rsc/CSharp.g3:2027:15: interfacetype dOT
						{
							pushFollow(FOLLOW_interfacetype_in_indexerdeclarator12504);
							interfacetype869 = interfacetype();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_interfacetype.add(interfacetype869
									.getTree());
							pushFollow(FOLLOW_dOT_in_indexerdeclarator12506);
							dOT870 = dOT();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_dOT.add(dOT870.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_tHIS_in_indexerdeclarator12510);
				tHIS871 = tHIS();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_tHIS.add(tHIS871.getTree());
				pushFollow(FOLLOW_lBRACKET_in_indexerdeclarator12512);
				lBRACKET872 = lBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACKET.add(lBRACKET872.getTree());
				pushFollow(FOLLOW_formalparameterlist_in_indexerdeclarator12514);
				formalparameterlist873 = formalparameterlist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_formalparameterlist.add(formalparameterlist873
						.getTree());
				pushFollow(FOLLOW_rBRACKET_in_indexerdeclarator12516);
				rBRACKET874 = rBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACKET.add(rBRACKET874.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						"this"
								+ "["
								+ (formalparameterlist873 != null ? formalparameterlist873.signature
										: null) + "]";
				}

				// AST REWRITE
				// elements: lBRACKET, interfacetype, type, tHIS, rBRACKET, formalparameterlist, dOT
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2029:2: -> type ( interfacetype dOT )? tHIS ^( ParameterList lBRACKET ( formalparameterlist )? rBRACKET )
					{
						this.adaptor.addChild(root_0, stream_type.nextTree());
						// ../rsc/CSharp.g3:2029:10: ( interfacetype dOT )?
						if (stream_interfacetype.hasNext()
								|| stream_dOT.hasNext()) {
							this.adaptor.addChild(
								root_0,
								stream_interfacetype.nextTree());
							this.adaptor.addChild(root_0, stream_dOT.nextTree());

						}
						stream_interfacetype.reset();
						stream_dOT.reset();
						this.adaptor.addChild(root_0, stream_tHIS.nextTree());
						// ../rsc/CSharp.g3:2029:36: ^( ParameterList lBRACKET ( formalparameterlist )? rBRACKET )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ParameterList,
										"ParameterList"),
									root_1);

							this.adaptor
								.addChild(root_1, stream_lBRACKET.nextTree());
							// ../rsc/CSharp.g3:2029:61: ( formalparameterlist )?
							if (stream_formalparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_formalparameterlist.nextTree());

							}
							stream_formalparameterlist.reset();
							this.adaptor
								.addChild(root_1, stream_rBRACKET.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "indexerdeclarator"

	public static class operatordeclaration_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "operatordeclaration"
	// ../rsc/CSharp.g3:2033:1: operatordeclaration returns [String signature] : ( attributes )? operatormodifiers operatordeclarator operatorbody -> ^( Operator ( attributes )? operatormodifiers operatordeclarator operatorbody ) ;
	public final CSharpParser.operatordeclaration_return operatordeclaration()
			throws RecognitionException {
		CSharpParser.operatordeclaration_return retval =
			new CSharpParser.operatordeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes875 = null;

		CSharpParser.operatormodifiers_return operatormodifiers876 = null;

		CSharpParser.operatordeclarator_return operatordeclarator877 = null;

		CSharpParser.operatorbody_return operatorbody878 = null;

		RewriteRuleSubtreeStream stream_operatormodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule operatormodifiers");
		RewriteRuleSubtreeStream stream_operatordeclarator =
			new RewriteRuleSubtreeStream(this.adaptor, "rule operatordeclarator");
		RewriteRuleSubtreeStream stream_operatorbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule operatorbody");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		try {
			// ../rsc/CSharp.g3:2037:5: ( ( attributes )? operatormodifiers operatordeclarator operatorbody -> ^( Operator ( attributes )? operatormodifiers operatordeclarator operatorbody ) )
			// ../rsc/CSharp.g3:2037:9: ( attributes )? operatormodifiers operatordeclarator operatorbody
			{
				// ../rsc/CSharp.g3:2037:9: ( attributes )?
				int alt196 = 2;
				int LA196_0 = this.input.LA(1);

				if ((LA196_0 == LBRACKET)) {
					alt196 = 1;
				}
				switch (alt196) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_operatordeclaration12577);
							attributes875 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes875.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_operatormodifiers_in_operatordeclaration12580);
				operatormodifiers876 = operatormodifiers();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_operatormodifiers
						.add(operatormodifiers876.getTree());
				pushFollow(FOLLOW_operatordeclarator_in_operatordeclaration12582);
				operatordeclarator877 = operatordeclarator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_operatordeclarator.add(operatordeclarator877
						.getTree());
				pushFollow(FOLLOW_operatorbody_in_operatordeclaration12584);
				operatorbody878 = operatorbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_operatorbody.add(operatorbody878.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(operatordeclarator877 != null ? operatordeclarator877.signature
								: null);
				}

				// AST REWRITE
				// elements: operatordeclarator, attributes, operatorbody, operatormodifiers
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2039:5: -> ^( Operator ( attributes )? operatormodifiers operatordeclarator operatorbody )
					{
						// ../rsc/CSharp.g3:2039:8: ^( Operator ( attributes )? operatormodifiers operatordeclarator operatorbody )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Operator, "Operator"), root_1);

							// ../rsc/CSharp.g3:2039:19: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							this.adaptor.addChild(
								root_1,
								stream_operatormodifiers.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_operatordeclarator.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_operatorbody.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.signature);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "operatordeclaration"

	public static class operatormodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "operatormodifiers"
	// ../rsc/CSharp.g3:2042:1: operatormodifiers : ( operatormodifier )+ -> ^( Modifiers ( operatormodifier )+ ) ;
	public final CSharpParser.operatormodifiers_return operatormodifiers()
			throws RecognitionException {
		CSharpParser.operatormodifiers_return retval =
			new CSharpParser.operatormodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.operatormodifier_return operatormodifier879 = null;

		RewriteRuleSubtreeStream stream_operatormodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule operatormodifier");
		try {
			// ../rsc/CSharp.g3:2043:5: ( ( operatormodifier )+ -> ^( Modifiers ( operatormodifier )+ ) )
			// ../rsc/CSharp.g3:2043:9: ( operatormodifier )+
			{
				// ../rsc/CSharp.g3:2043:9: ( operatormodifier )+
				int cnt197 = 0;
				loop197: do {
					int alt197 = 2;
					int LA197_0 = this.input.LA(1);

					if ((LA197_0 == EXTERN || LA197_0 == PUBLIC || LA197_0 == STATIC)) {
						alt197 = 1;
					}

					switch (alt197) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: operatormodifier
							{
								pushFollow(FOLLOW_operatormodifier_in_operatormodifiers12630);
								operatormodifier879 = operatormodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_operatormodifier
										.add(operatormodifier879.getTree());

							}
							break;

						default :
							if (cnt197 >= 1)
								break loop197;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(197, this.input);
							throw eee;
					}
					cnt197++;
				}
				while (true);

				// AST REWRITE
				// elements: operatormodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2044:5: -> ^( Modifiers ( operatormodifier )+ )
					{
						// ../rsc/CSharp.g3:2044:8: ^( Modifiers ( operatormodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_operatormodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_operatormodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_operatormodifier.nextTree());

							}
							stream_operatormodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "operatormodifiers"

	public static class operatormodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "operatormodifier"
	// ../rsc/CSharp.g3:2047:1: operatormodifier : ( pUBLIC | sTATIC | eXTERN );
	public final CSharpParser.operatormodifier_return operatormodifier()
			throws RecognitionException {
		CSharpParser.operatormodifier_return retval =
			new CSharpParser.operatormodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.pUBLIC_return pUBLIC880 = null;

		CSharpParser.sTATIC_return sTATIC881 = null;

		CSharpParser.eXTERN_return eXTERN882 = null;

		try {
			// ../rsc/CSharp.g3:2048:5: ( pUBLIC | sTATIC | eXTERN )
			int alt198 = 3;
			switch (this.input.LA(1)) {
				case PUBLIC :
					{
						alt198 = 1;
					}
					break;
				case STATIC :
					{
						alt198 = 2;
					}
					break;
				case EXTERN :
					{
						alt198 = 3;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 198, 0, this.input);

					throw nvae;
			}

			switch (alt198) {
				case 1 :
				// ../rsc/CSharp.g3:2048:9: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_operatormodifier12663);
						pUBLIC880 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC880.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2049:9: sTATIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sTATIC_in_operatormodifier12673);
						sTATIC881 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sTATIC881.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2050:9: eXTERN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXTERN_in_operatormodifier12683);
						eXTERN882 = eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXTERN882.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "operatormodifier"

	public static class operatordeclarator_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "operatordeclarator"
	// ../rsc/CSharp.g3:2053:1: operatordeclarator returns [String signature] : ( unaryoperatordeclarator -> ^( UnaryOperatorDeclarator unaryoperatordeclarator ) | binaryoperatordeclarator -> ^( BinaryOperatorDeclarator binaryoperatordeclarator ) | conversionoperatordeclarator -> ^( ConversionOperatorDeclarator conversionoperatordeclarator ) );
	public final CSharpParser.operatordeclarator_return operatordeclarator()
			throws RecognitionException {
		CSharpParser.operatordeclarator_return retval =
			new CSharpParser.operatordeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.unaryoperatordeclarator_return unaryoperatordeclarator883 =
			null;

		CSharpParser.binaryoperatordeclarator_return binaryoperatordeclarator884 =
			null;

		CSharpParser.conversionoperatordeclarator_return conversionoperatordeclarator885 =
			null;

		RewriteRuleSubtreeStream stream_binaryoperatordeclarator =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule binaryoperatordeclarator");
		RewriteRuleSubtreeStream stream_unaryoperatordeclarator =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule unaryoperatordeclarator");
		RewriteRuleSubtreeStream stream_conversionoperatordeclarator =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule conversionoperatordeclarator");
		try {
			// ../rsc/CSharp.g3:2054:5: ( unaryoperatordeclarator -> ^( UnaryOperatorDeclarator unaryoperatordeclarator ) | binaryoperatordeclarator -> ^( BinaryOperatorDeclarator binaryoperatordeclarator ) | conversionoperatordeclarator -> ^( ConversionOperatorDeclarator conversionoperatordeclarator ) )
			int alt199 = 3;
			alt199 = this.dfa199.predict(this.input);
			switch (alt199) {
				case 1 :
				// ../rsc/CSharp.g3:2054:9: unaryoperatordeclarator
					{
						pushFollow(FOLLOW_unaryoperatordeclarator_in_operatordeclarator12706);
						unaryoperatordeclarator883 = unaryoperatordeclarator();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_unaryoperatordeclarator
								.add(unaryoperatordeclarator883.getTree());
						if (this.state.backtracking == 0) {
							retval.signature =
								(unaryoperatordeclarator883 != null ? unaryoperatordeclarator883.signature
										: null);
						}

						// AST REWRITE
						// elements: unaryoperatordeclarator
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2056:5: -> ^( UnaryOperatorDeclarator unaryoperatordeclarator )
							{
								// ../rsc/CSharp.g3:2056:8: ^( UnaryOperatorDeclarator unaryoperatordeclarator )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												UnaryOperatorDeclarator,
												"UnaryOperatorDeclarator"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_unaryoperatordeclarator
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2057:9: binaryoperatordeclarator
					{
						pushFollow(FOLLOW_binaryoperatordeclarator_in_operatordeclarator12735);
						binaryoperatordeclarator884 =
							binaryoperatordeclarator();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_binaryoperatordeclarator
								.add(binaryoperatordeclarator884.getTree());
						if (this.state.backtracking == 0) {
							retval.signature =
								(binaryoperatordeclarator884 != null ? binaryoperatordeclarator884.signature
										: null);
						}

						// AST REWRITE
						// elements: binaryoperatordeclarator
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2059:5: -> ^( BinaryOperatorDeclarator binaryoperatordeclarator )
							{
								// ../rsc/CSharp.g3:2059:8: ^( BinaryOperatorDeclarator binaryoperatordeclarator )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												BinaryOperatorDeclarator,
												"BinaryOperatorDeclarator"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_binaryoperatordeclarator
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2060:9: conversionoperatordeclarator
					{
						pushFollow(FOLLOW_conversionoperatordeclarator_in_operatordeclarator12764);
						conversionoperatordeclarator885 =
							conversionoperatordeclarator();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_conversionoperatordeclarator
								.add(conversionoperatordeclarator885.getTree());
						if (this.state.backtracking == 0) {
							retval.signature =
								(conversionoperatordeclarator885 != null ? conversionoperatordeclarator885.signature
										: null);
						}

						// AST REWRITE
						// elements: conversionoperatordeclarator
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2062:5: -> ^( ConversionOperatorDeclarator conversionoperatordeclarator )
							{
								// ../rsc/CSharp.g3:2062:8: ^( ConversionOperatorDeclarator conversionoperatordeclarator )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor
											.becomeRoot(
												(Object) this.adaptor
													.create(
														ConversionOperatorDeclarator,
														"ConversionOperatorDeclarator"),
												root_1);

									this.adaptor.addChild(
										root_1,
										stream_conversionoperatordeclarator
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "operatordeclarator"

	public static class unaryoperatordeclarator_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "unaryoperatordeclarator"
	// ../rsc/CSharp.g3:2065:1: unaryoperatordeclarator returns [String signature] : type oPERATOR overloadableunaryoperator lPAREN t1= type identifier rPAREN -> type oPERATOR ^( UnaryOperator overloadableunaryoperator ) ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN ) ;
	public final CSharpParser.unaryoperatordeclarator_return unaryoperatordeclarator()
			throws RecognitionException {
		CSharpParser.unaryoperatordeclarator_return retval =
			new CSharpParser.unaryoperatordeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.type_return t1 = null;

		CSharpParser.type_return type886 = null;

		CSharpParser.oPERATOR_return oPERATOR887 = null;

		CSharpParser.overloadableunaryoperator_return overloadableunaryoperator888 =
			null;

		CSharpParser.lPAREN_return lPAREN889 = null;

		CSharpParser.identifier_return identifier890 = null;

		CSharpParser.rPAREN_return rPAREN891 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_oPERATOR =
			new RewriteRuleSubtreeStream(this.adaptor, "rule oPERATOR");
		RewriteRuleSubtreeStream stream_overloadableunaryoperator =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule overloadableunaryoperator");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:2066:5: ( type oPERATOR overloadableunaryoperator lPAREN t1= type identifier rPAREN -> type oPERATOR ^( UnaryOperator overloadableunaryoperator ) ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN ) )
			// ../rsc/CSharp.g3:2066:9: type oPERATOR overloadableunaryoperator lPAREN t1= type identifier rPAREN
			{
				pushFollow(FOLLOW_type_in_unaryoperatordeclarator12806);
				type886 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type886.getTree());
				pushFollow(FOLLOW_oPERATOR_in_unaryoperatordeclarator12808);
				oPERATOR887 = oPERATOR();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_oPERATOR.add(oPERATOR887.getTree());
				pushFollow(FOLLOW_overloadableunaryoperator_in_unaryoperatordeclarator12810);
				overloadableunaryoperator888 = overloadableunaryoperator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_overloadableunaryoperator
						.add(overloadableunaryoperator888.getTree());
				pushFollow(FOLLOW_lPAREN_in_unaryoperatordeclarator12812);
				lPAREN889 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN889.getTree());
				pushFollow(FOLLOW_type_in_unaryoperatordeclarator12816);
				t1 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(t1.getTree());
				pushFollow(FOLLOW_identifier_in_unaryoperatordeclarator12818);
				identifier890 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier890.getTree());
				pushFollow(FOLLOW_rPAREN_in_unaryoperatordeclarator12820);
				rPAREN891 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN891.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(overloadableunaryoperator888 != null ? overloadableunaryoperator888.content
								: null)
								+ '(' + (t1 != null ? t1.name : null) + ')';
				}

				// AST REWRITE
				// elements: lPAREN, oPERATOR, type, rPAREN, overloadableunaryoperator, identifier, type
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2068:5: -> type oPERATOR ^( UnaryOperator overloadableunaryoperator ) ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN )
					{
						this.adaptor.addChild(root_0, stream_type.nextTree());
						this.adaptor.addChild(root_0, stream_oPERATOR.nextTree());
						// ../rsc/CSharp.g3:2068:22: ^( UnaryOperator overloadableunaryoperator )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										UnaryOperator,
										"UnaryOperator"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_overloadableunaryoperator.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}
						// ../rsc/CSharp.g3:2069:6: ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ParameterList,
										"ParameterList"),
									root_1);

							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							// ../rsc/CSharp.g3:2069:29: ^( Parameter type identifier )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											Parameter,
											"Parameter"),
										root_2);

								this.adaptor
									.addChild(root_2, stream_type.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_identifier.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "unaryoperatordeclarator"

	public static class overloadableunaryoperator_return extends
			ParserRuleReturnScope {
		public String content;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "overloadableunaryoperator"
	// ../rsc/CSharp.g3:2072:1: overloadableunaryoperator returns [String content] : ( pLUS | mINUS | eXCLAM | tILDE | iNCREMENT | dECREMENT | tRUE | fALSE );
	public final CSharpParser.overloadableunaryoperator_return overloadableunaryoperator()
			throws RecognitionException {
		CSharpParser.overloadableunaryoperator_return retval =
			new CSharpParser.overloadableunaryoperator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.pLUS_return pLUS892 = null;

		CSharpParser.mINUS_return mINUS893 = null;

		CSharpParser.eXCLAM_return eXCLAM894 = null;

		CSharpParser.tILDE_return tILDE895 = null;

		CSharpParser.iNCREMENT_return iNCREMENT896 = null;

		CSharpParser.dECREMENT_return dECREMENT897 = null;

		CSharpParser.tRUE_return tRUE898 = null;

		CSharpParser.fALSE_return fALSE899 = null;

		try {
			// ../rsc/CSharp.g3:2073:5: ( pLUS | mINUS | eXCLAM | tILDE | iNCREMENT | dECREMENT | tRUE | fALSE )
			int alt200 = 8;
			switch (this.input.LA(1)) {
				case PLUS :
					{
						alt200 = 1;
					}
					break;
				case MINUS :
					{
						alt200 = 2;
					}
					break;
				case EXCLAM :
					{
						alt200 = 3;
					}
					break;
				case TILDE :
					{
						alt200 = 4;
					}
					break;
				case INCREMENT :
					{
						alt200 = 5;
					}
					break;
				case DECREMENT :
					{
						alt200 = 6;
					}
					break;
				case TRUE :
					{
						alt200 = 7;
					}
					break;
				case FALSE :
					{
						alt200 = 8;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 200, 0, this.input);

					throw nvae;
			}

			switch (alt200) {
				case 1 :
				// ../rsc/CSharp.g3:2073:7: pLUS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pLUS_in_overloadableunaryoperator12885);
						pLUS892 = pLUS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pLUS892.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "+";
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2074:7: mINUS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_mINUS_in_overloadableunaryoperator12896);
						mINUS893 = mINUS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, mINUS893.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "-";
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2075:7: eXCLAM
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXCLAM_in_overloadableunaryoperator12906);
						eXCLAM894 = eXCLAM();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXCLAM894.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "!";
						}

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2076:7: tILDE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tILDE_in_overloadableunaryoperator12916);
						tILDE895 = tILDE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tILDE895.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "~";
						}

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2077:7: iNCREMENT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNCREMENT_in_overloadableunaryoperator12926);
						iNCREMENT896 = iNCREMENT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNCREMENT896.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "++";
						}

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:2078:7: dECREMENT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dECREMENT_in_overloadableunaryoperator12936);
						dECREMENT897 = dECREMENT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dECREMENT897.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "--";
						}

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:2079:7: tRUE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tRUE_in_overloadableunaryoperator12946);
						tRUE898 = tRUE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tRUE898.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "true";
						}

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:2080:7: fALSE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fALSE_in_overloadableunaryoperator12956);
						fALSE899 = fALSE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fALSE899.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "false";
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "overloadableunaryoperator"

	public static class binaryoperatordeclarator_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "binaryoperatordeclarator"
	// ../rsc/CSharp.g3:2083:1: binaryoperatordeclarator returns [String signature] : type oPERATOR overloadablebinaryoperator lPAREN t1= type identifier cOMMA t2= type identifier rPAREN -> type oPERATOR ^( BinaryOperator overloadablebinaryoperator ) ^( ParameterList lPAREN ^( Parameter type identifier ) cOMMA ^( Parameter type identifier ) rPAREN ) ;
	public final CSharpParser.binaryoperatordeclarator_return binaryoperatordeclarator()
			throws RecognitionException {
		CSharpParser.binaryoperatordeclarator_return retval =
			new CSharpParser.binaryoperatordeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.type_return t1 = null;

		CSharpParser.type_return t2 = null;

		CSharpParser.type_return type900 = null;

		CSharpParser.oPERATOR_return oPERATOR901 = null;

		CSharpParser.overloadablebinaryoperator_return overloadablebinaryoperator902 =
			null;

		CSharpParser.lPAREN_return lPAREN903 = null;

		CSharpParser.identifier_return identifier904 = null;

		CSharpParser.cOMMA_return cOMMA905 = null;

		CSharpParser.identifier_return identifier906 = null;

		CSharpParser.rPAREN_return rPAREN907 = null;

		RewriteRuleSubtreeStream stream_overloadablebinaryoperator =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule overloadablebinaryoperator");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_oPERATOR =
			new RewriteRuleSubtreeStream(this.adaptor, "rule oPERATOR");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:2084:5: ( type oPERATOR overloadablebinaryoperator lPAREN t1= type identifier cOMMA t2= type identifier rPAREN -> type oPERATOR ^( BinaryOperator overloadablebinaryoperator ) ^( ParameterList lPAREN ^( Parameter type identifier ) cOMMA ^( Parameter type identifier ) rPAREN ) )
			// ../rsc/CSharp.g3:2084:9: type oPERATOR overloadablebinaryoperator lPAREN t1= type identifier cOMMA t2= type identifier rPAREN
			{
				pushFollow(FOLLOW_type_in_binaryoperatordeclarator12981);
				type900 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type900.getTree());
				pushFollow(FOLLOW_oPERATOR_in_binaryoperatordeclarator12983);
				oPERATOR901 = oPERATOR();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_oPERATOR.add(oPERATOR901.getTree());
				pushFollow(FOLLOW_overloadablebinaryoperator_in_binaryoperatordeclarator12985);
				overloadablebinaryoperator902 = overloadablebinaryoperator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_overloadablebinaryoperator
						.add(overloadablebinaryoperator902.getTree());
				pushFollow(FOLLOW_lPAREN_in_binaryoperatordeclarator12987);
				lPAREN903 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN903.getTree());
				pushFollow(FOLLOW_type_in_binaryoperatordeclarator12991);
				t1 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(t1.getTree());
				pushFollow(FOLLOW_identifier_in_binaryoperatordeclarator12993);
				identifier904 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier904.getTree());
				pushFollow(FOLLOW_cOMMA_in_binaryoperatordeclarator12995);
				cOMMA905 = cOMMA();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cOMMA.add(cOMMA905.getTree());
				pushFollow(FOLLOW_type_in_binaryoperatordeclarator12999);
				t2 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(t2.getTree());
				pushFollow(FOLLOW_identifier_in_binaryoperatordeclarator13001);
				identifier906 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier906.getTree());
				pushFollow(FOLLOW_rPAREN_in_binaryoperatordeclarator13003);
				rPAREN907 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN907.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(overloadablebinaryoperator902 != null ? overloadablebinaryoperator902.content
								: null)
								+ '('
								+ (t1 != null ? t1.name : null)
								+ ','
								+ (t2 != null ? t2.name : null) + ')';
				}

				// AST REWRITE
				// elements: oPERATOR, identifier, rPAREN, identifier, lPAREN, cOMMA, overloadablebinaryoperator, type, type, type
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2086:5: -> type oPERATOR ^( BinaryOperator overloadablebinaryoperator ) ^( ParameterList lPAREN ^( Parameter type identifier ) cOMMA ^( Parameter type identifier ) rPAREN )
					{
						this.adaptor.addChild(root_0, stream_type.nextTree());
						this.adaptor.addChild(root_0, stream_oPERATOR.nextTree());
						// ../rsc/CSharp.g3:2086:22: ^( BinaryOperator overloadablebinaryoperator )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										BinaryOperator,
										"BinaryOperator"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_overloadablebinaryoperator.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}
						// ../rsc/CSharp.g3:2087:6: ^( ParameterList lPAREN ^( Parameter type identifier ) cOMMA ^( Parameter type identifier ) rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ParameterList,
										"ParameterList"),
									root_1);

							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							// ../rsc/CSharp.g3:2087:29: ^( Parameter type identifier )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											Parameter,
											"Parameter"),
										root_2);

								this.adaptor
									.addChild(root_2, stream_type.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_identifier.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}
							this.adaptor.addChild(root_1, stream_cOMMA.nextTree());
							// ../rsc/CSharp.g3:2087:64: ^( Parameter type identifier )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											Parameter,
											"Parameter"),
										root_2);

								this.adaptor
									.addChild(root_2, stream_type.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_identifier.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "binaryoperatordeclarator"

	public static class overloadablebinaryoperator_return extends
			ParserRuleReturnScope {
		public String content;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "overloadablebinaryoperator"
	// ../rsc/CSharp.g3:2090:1: overloadablebinaryoperator returns [String content] : ( pLUS | mUL | dIV | mOD | aMPERSAND | bITWISEOR | bITWISEXOR | lEFTSHIFT | rIGHTSHIFT | eQUALS | nOTEQUALS | gT | lT | gE | lE );
	public final CSharpParser.overloadablebinaryoperator_return overloadablebinaryoperator()
			throws RecognitionException {
		CSharpParser.overloadablebinaryoperator_return retval =
			new CSharpParser.overloadablebinaryoperator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.pLUS_return pLUS908 = null;

		CSharpParser.mUL_return mUL909 = null;

		CSharpParser.dIV_return dIV910 = null;

		CSharpParser.mOD_return mOD911 = null;

		CSharpParser.aMPERSAND_return aMPERSAND912 = null;

		CSharpParser.bITWISEOR_return bITWISEOR913 = null;

		CSharpParser.bITWISEXOR_return bITWISEXOR914 = null;

		CSharpParser.lEFTSHIFT_return lEFTSHIFT915 = null;

		CSharpParser.rIGHTSHIFT_return rIGHTSHIFT916 = null;

		CSharpParser.eQUALS_return eQUALS917 = null;

		CSharpParser.nOTEQUALS_return nOTEQUALS918 = null;

		CSharpParser.gT_return gT919 = null;

		CSharpParser.lT_return lT920 = null;

		CSharpParser.gE_return gE921 = null;

		CSharpParser.lE_return lE922 = null;

		try {
			// ../rsc/CSharp.g3:2091:5: ( pLUS | mUL | dIV | mOD | aMPERSAND | bITWISEOR | bITWISEXOR | lEFTSHIFT | rIGHTSHIFT | eQUALS | nOTEQUALS | gT | lT | gE | lE )
			int alt201 = 15;
			alt201 = this.dfa201.predict(this.input);
			switch (alt201) {
				case 1 :
				// ../rsc/CSharp.g3:2091:8: pLUS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pLUS_in_overloadablebinaryoperator13079);
						pLUS908 = pLUS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pLUS908.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "+";
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2092:8: mUL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_mUL_in_overloadablebinaryoperator13090);
						mUL909 = mUL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, mUL909.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "-";
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2093:8: dIV
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_dIV_in_overloadablebinaryoperator13101);
						dIV910 = dIV();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, dIV910.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "/";
						}

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2094:8: mOD
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_mOD_in_overloadablebinaryoperator13112);
						mOD911 = mOD();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, mOD911.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "*";
						}

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2095:8: aMPERSAND
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_aMPERSAND_in_overloadablebinaryoperator13123);
						aMPERSAND912 = aMPERSAND();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, aMPERSAND912.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "&";
						}

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:2096:8: bITWISEOR
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bITWISEOR_in_overloadablebinaryoperator13134);
						bITWISEOR913 = bITWISEOR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bITWISEOR913.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "|";
						}

					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:2097:8: bITWISEXOR
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_bITWISEXOR_in_overloadablebinaryoperator13145);
						bITWISEXOR914 = bITWISEXOR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, bITWISEXOR914.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "^";
						}

					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:2098:9: lEFTSHIFT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lEFTSHIFT_in_overloadablebinaryoperator13157);
						lEFTSHIFT915 = lEFTSHIFT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, lEFTSHIFT915.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "<<";
						}

					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:2099:8: rIGHTSHIFT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_rIGHTSHIFT_in_overloadablebinaryoperator13168);
						rIGHTSHIFT916 = rIGHTSHIFT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, rIGHTSHIFT916.getTree());
						if (this.state.backtracking == 0) {
							retval.content = ">>";
						}

					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:2100:8: eQUALS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eQUALS_in_overloadablebinaryoperator13179);
						eQUALS917 = eQUALS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eQUALS917.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "==";
						}

					}
					break;
				case 11 :
				// ../rsc/CSharp.g3:2101:8: nOTEQUALS
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nOTEQUALS_in_overloadablebinaryoperator13190);
						nOTEQUALS918 = nOTEQUALS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nOTEQUALS918.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "!=";
						}

					}
					break;
				case 12 :
				// ../rsc/CSharp.g3:2102:8: gT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_gT_in_overloadablebinaryoperator13201);
						gT919 = gT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, gT919.getTree());
						if (this.state.backtracking == 0) {
							retval.content = ">";
						}

					}
					break;
				case 13 :
				// ../rsc/CSharp.g3:2103:8: lT
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lT_in_overloadablebinaryoperator13212);
						lT920 = lT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, lT920.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "<";
						}

					}
					break;
				case 14 :
				// ../rsc/CSharp.g3:2104:8: gE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_gE_in_overloadablebinaryoperator13223);
						gE921 = gE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, gE921.getTree());
						if (this.state.backtracking == 0) {
							retval.content = ">=";
						}

					}
					break;
				case 15 :
				// ../rsc/CSharp.g3:2105:8: lE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_lE_in_overloadablebinaryoperator13234);
						lE922 = lE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, lE922.getTree());
						if (this.state.backtracking == 0) {
							retval.content = "<=";
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "overloadablebinaryoperator"

	public static class conversionoperatordeclarator_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "conversionoperatordeclarator"
	// ../rsc/CSharp.g3:2108:1: conversionoperatordeclarator returns [String signature] : ( iMPLICIT oPERATOR tret= type lPAREN tparam= type identifier rPAREN -> iMPLICIT oPERATOR type ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN ) | eXPLICIT oPERATOR tret= type lPAREN tparam= type identifier rPAREN -> eXPLICIT oPERATOR type ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN ) );
	public final CSharpParser.conversionoperatordeclarator_return conversionoperatordeclarator()
			throws RecognitionException {
		CSharpParser.conversionoperatordeclarator_return retval =
			new CSharpParser.conversionoperatordeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.type_return tret = null;

		CSharpParser.type_return tparam = null;

		CSharpParser.iMPLICIT_return iMPLICIT923 = null;

		CSharpParser.oPERATOR_return oPERATOR924 = null;

		CSharpParser.lPAREN_return lPAREN925 = null;

		CSharpParser.identifier_return identifier926 = null;

		CSharpParser.rPAREN_return rPAREN927 = null;

		CSharpParser.eXPLICIT_return eXPLICIT928 = null;

		CSharpParser.oPERATOR_return oPERATOR929 = null;

		CSharpParser.lPAREN_return lPAREN930 = null;

		CSharpParser.identifier_return identifier931 = null;

		CSharpParser.rPAREN_return rPAREN932 = null;

		RewriteRuleSubtreeStream stream_iMPLICIT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule iMPLICIT");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_eXPLICIT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eXPLICIT");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_oPERATOR =
			new RewriteRuleSubtreeStream(this.adaptor, "rule oPERATOR");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:2109:5: ( iMPLICIT oPERATOR tret= type lPAREN tparam= type identifier rPAREN -> iMPLICIT oPERATOR type ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN ) | eXPLICIT oPERATOR tret= type lPAREN tparam= type identifier rPAREN -> eXPLICIT oPERATOR type ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN ) )
			int alt202 = 2;
			int LA202_0 = this.input.LA(1);

			if ((LA202_0 == IMPLICIT)) {
				alt202 = 1;
			}
			else if ((LA202_0 == EXPLICIT)) {
				alt202 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 202, 0, this.input);

				throw nvae;
			}
			switch (alt202) {
				case 1 :
				// ../rsc/CSharp.g3:2109:9: iMPLICIT oPERATOR tret= type lPAREN tparam= type identifier rPAREN
					{
						pushFollow(FOLLOW_iMPLICIT_in_conversionoperatordeclarator13259);
						iMPLICIT923 = iMPLICIT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_iMPLICIT.add(iMPLICIT923.getTree());
						pushFollow(FOLLOW_oPERATOR_in_conversionoperatordeclarator13261);
						oPERATOR924 = oPERATOR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_oPERATOR.add(oPERATOR924.getTree());
						pushFollow(FOLLOW_type_in_conversionoperatordeclarator13265);
						tret = type();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_type.add(tret.getTree());
						pushFollow(FOLLOW_lPAREN_in_conversionoperatordeclarator13267);
						lPAREN925 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN925.getTree());
						pushFollow(FOLLOW_type_in_conversionoperatordeclarator13271);
						tparam = type();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_type.add(tparam.getTree());
						pushFollow(FOLLOW_identifier_in_conversionoperatordeclarator13273);
						identifier926 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier926.getTree());
						pushFollow(FOLLOW_rPAREN_in_conversionoperatordeclarator13275);
						rPAREN927 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN927.getTree());
						if (this.state.backtracking == 0) {
							retval.signature =
								(tret != null ? tret.name : null) + '('
										+ (tparam != null ? tparam.name : null)
										+ ')';
						}

						// AST REWRITE
						// elements: identifier, lPAREN, type, type, oPERATOR, rPAREN, iMPLICIT
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2111:5: -> iMPLICIT oPERATOR type ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN )
							{
								this.adaptor.addChild(
									root_0,
									stream_iMPLICIT.nextTree());
								this.adaptor.addChild(
									root_0,
									stream_oPERATOR.nextTree());
								this.adaptor
									.addChild(root_0, stream_type.nextTree());
								// ../rsc/CSharp.g3:2111:31: ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ParameterList,
												"ParameterList"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									// ../rsc/CSharp.g3:2111:54: ^( Parameter type identifier )
									{
										Object root_2 = (Object) this.adaptor.nil();
										root_2 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													Parameter,
													"Parameter"),
												root_2);

										this.adaptor.addChild(
											root_2,
											stream_type.nextTree());
										this.adaptor.addChild(
											root_2,
											stream_identifier.nextTree());

										this.adaptor.addChild(root_1, root_2);
									}
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2112:9: eXPLICIT oPERATOR tret= type lPAREN tparam= type identifier rPAREN
					{
						pushFollow(FOLLOW_eXPLICIT_in_conversionoperatordeclarator13320);
						eXPLICIT928 = eXPLICIT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_eXPLICIT.add(eXPLICIT928.getTree());
						pushFollow(FOLLOW_oPERATOR_in_conversionoperatordeclarator13322);
						oPERATOR929 = oPERATOR();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_oPERATOR.add(oPERATOR929.getTree());
						pushFollow(FOLLOW_type_in_conversionoperatordeclarator13326);
						tret = type();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_type.add(tret.getTree());
						pushFollow(FOLLOW_lPAREN_in_conversionoperatordeclarator13328);
						lPAREN930 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN930.getTree());
						pushFollow(FOLLOW_type_in_conversionoperatordeclarator13332);
						tparam = type();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_type.add(tparam.getTree());
						pushFollow(FOLLOW_identifier_in_conversionoperatordeclarator13334);
						identifier931 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier931.getTree());
						pushFollow(FOLLOW_rPAREN_in_conversionoperatordeclarator13336);
						rPAREN932 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN932.getTree());
						if (this.state.backtracking == 0) {
							retval.signature =
								(tret != null ? tret.name : null) + '('
										+ (tparam != null ? tparam.name : null)
										+ ')';
						}

						// AST REWRITE
						// elements: rPAREN, identifier, eXPLICIT, lPAREN, oPERATOR, type, type
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2114:5: -> eXPLICIT oPERATOR type ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN )
							{
								this.adaptor.addChild(
									root_0,
									stream_eXPLICIT.nextTree());
								this.adaptor.addChild(
									root_0,
									stream_oPERATOR.nextTree());
								this.adaptor
									.addChild(root_0, stream_type.nextTree());
								// ../rsc/CSharp.g3:2114:31: ^( ParameterList lPAREN ^( Parameter type identifier ) rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ParameterList,
												"ParameterList"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									// ../rsc/CSharp.g3:2114:54: ^( Parameter type identifier )
									{
										Object root_2 = (Object) this.adaptor.nil();
										root_2 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													Parameter,
													"Parameter"),
												root_2);

										this.adaptor.addChild(
											root_2,
											stream_type.nextTree());
										this.adaptor.addChild(
											root_2,
											stream_identifier.nextTree());

										this.adaptor.addChild(root_1, root_2);
									}
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "conversionoperatordeclarator"

	public static class operatorbody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "operatorbody"
	// ../rsc/CSharp.g3:2117:1: operatorbody : ( block | sEMICOLON );
	public final CSharpParser.operatorbody_return operatorbody()
			throws RecognitionException {
		CSharpParser.operatorbody_return retval =
			new CSharpParser.operatorbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.block_return block933 = null;

		CSharpParser.sEMICOLON_return sEMICOLON934 = null;

		try {
			// ../rsc/CSharp.g3:2118:5: ( block | sEMICOLON )
			int alt203 = 2;
			int LA203_0 = this.input.LA(1);

			if ((LA203_0 == LBRACE)) {
				alt203 = 1;
			}
			else if ((LA203_0 == SEMICOLON)) {
				alt203 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 203, 0, this.input);

				throw nvae;
			}
			switch (alt203) {
				case 1 :
				// ../rsc/CSharp.g3:2118:9: block
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_block_in_operatorbody13390);
						block933 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, block933.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2119:9: sEMICOLON
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEMICOLON_in_operatorbody13400);
						sEMICOLON934 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEMICOLON934.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "operatorbody"

	public static class constructordeclaration_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constructordeclaration"
	// ../rsc/CSharp.g3:2122:1: constructordeclaration returns [String signature] : ( attributes )? ( constructormodifiers )? constructordeclarator constructorbody -> ^( Constructor ( attributes )? ( constructormodifiers )? constructordeclarator constructorbody ) ;
	public final CSharpParser.constructordeclaration_return constructordeclaration()
			throws RecognitionException {
		CSharpParser.constructordeclaration_return retval =
			new CSharpParser.constructordeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes935 = null;

		CSharpParser.constructormodifiers_return constructormodifiers936 = null;

		CSharpParser.constructordeclarator_return constructordeclarator937 =
			null;

		CSharpParser.constructorbody_return constructorbody938 = null;

		RewriteRuleSubtreeStream stream_constructorbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constructorbody");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_constructordeclarator =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constructordeclarator");
		RewriteRuleSubtreeStream stream_constructormodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constructormodifiers");
		try {
			// ../rsc/CSharp.g3:2126:5: ( ( attributes )? ( constructormodifiers )? constructordeclarator constructorbody -> ^( Constructor ( attributes )? ( constructormodifiers )? constructordeclarator constructorbody ) )
			// ../rsc/CSharp.g3:2126:9: ( attributes )? ( constructormodifiers )? constructordeclarator constructorbody
			{
				// ../rsc/CSharp.g3:2126:9: ( attributes )?
				int alt204 = 2;
				int LA204_0 = this.input.LA(1);

				if ((LA204_0 == LBRACKET)) {
					alt204 = 1;
				}
				switch (alt204) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_constructordeclaration13428);
							attributes935 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes935.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2126:21: ( constructormodifiers )?
				int alt205 = 2;
				int LA205_0 = this.input.LA(1);

				if ((LA205_0 == EXTERN || LA205_0 == INTERNAL || (LA205_0 >= PRIVATE && LA205_0 <= PUBLIC))) {
					alt205 = 1;
				}
				switch (alt205) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: constructormodifiers
						{
							pushFollow(FOLLOW_constructormodifiers_in_constructordeclaration13431);
							constructormodifiers936 = constructormodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_constructormodifiers
									.add(constructormodifiers936.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_constructordeclarator_in_constructordeclaration13434);
				constructordeclarator937 = constructordeclarator();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_constructordeclarator.add(constructordeclarator937
						.getTree());
				pushFollow(FOLLOW_constructorbody_in_constructordeclaration13436);
				constructorbody938 = constructorbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_constructorbody.add(constructorbody938.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(constructordeclarator937 != null ? constructordeclarator937.signature
								: null);
				}

				// AST REWRITE
				// elements: constructormodifiers, constructorbody, constructordeclarator, attributes
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2128:5: -> ^( Constructor ( attributes )? ( constructormodifiers )? constructordeclarator constructorbody )
					{
						// ../rsc/CSharp.g3:2128:8: ^( Constructor ( attributes )? ( constructormodifiers )? constructordeclarator constructorbody )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor
									.becomeRoot((Object) this.adaptor.create(
										Constructor,
										"Constructor"), root_1);

							// ../rsc/CSharp.g3:2128:22: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2128:34: ( constructormodifiers )?
							if (stream_constructormodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_constructormodifiers.nextTree());

							}
							stream_constructormodifiers.reset();
							this.adaptor.addChild(
								root_1,
								stream_constructordeclarator.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_constructorbody.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.signature);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constructordeclaration"

	public static class constructormodifiers_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constructormodifiers"
	// ../rsc/CSharp.g3:2131:1: constructormodifiers : ( constructormodifier )+ -> ^( Modifiers ( constructormodifier )+ ) ;
	public final CSharpParser.constructormodifiers_return constructormodifiers()
			throws RecognitionException {
		CSharpParser.constructormodifiers_return retval =
			new CSharpParser.constructormodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.constructormodifier_return constructormodifier939 = null;

		RewriteRuleSubtreeStream stream_constructormodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constructormodifier");
		try {
			// ../rsc/CSharp.g3:2132:5: ( ( constructormodifier )+ -> ^( Modifiers ( constructormodifier )+ ) )
			// ../rsc/CSharp.g3:2132:9: ( constructormodifier )+
			{
				// ../rsc/CSharp.g3:2132:9: ( constructormodifier )+
				int cnt206 = 0;
				loop206: do {
					int alt206 = 2;
					int LA206_0 = this.input.LA(1);

					if ((LA206_0 == EXTERN || LA206_0 == INTERNAL || (LA206_0 >= PRIVATE && LA206_0 <= PUBLIC))) {
						alt206 = 1;
					}

					switch (alt206) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: constructormodifier
							{
								pushFollow(FOLLOW_constructormodifier_in_constructormodifiers13483);
								constructormodifier939 = constructormodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_constructormodifier
										.add(constructormodifier939.getTree());

							}
							break;

						default :
							if (cnt206 >= 1)
								break loop206;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(206, this.input);
							throw eee;
					}
					cnt206++;
				}
				while (true);

				// AST REWRITE
				// elements: constructormodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2133:5: -> ^( Modifiers ( constructormodifier )+ )
					{
						// ../rsc/CSharp.g3:2133:8: ^( Modifiers ( constructormodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_constructormodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_constructormodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_constructormodifier.nextTree());

							}
							stream_constructormodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constructormodifiers"

	public static class constructormodifier_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constructormodifier"
	// ../rsc/CSharp.g3:2136:1: constructormodifier : ( pUBLIC | pROTECTED | iNTERNAL | pRIVATE | eXTERN );
	public final CSharpParser.constructormodifier_return constructormodifier()
			throws RecognitionException {
		CSharpParser.constructormodifier_return retval =
			new CSharpParser.constructormodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.pUBLIC_return pUBLIC940 = null;

		CSharpParser.pROTECTED_return pROTECTED941 = null;

		CSharpParser.iNTERNAL_return iNTERNAL942 = null;

		CSharpParser.pRIVATE_return pRIVATE943 = null;

		CSharpParser.eXTERN_return eXTERN944 = null;

		try {
			// ../rsc/CSharp.g3:2137:5: ( pUBLIC | pROTECTED | iNTERNAL | pRIVATE | eXTERN )
			int alt207 = 5;
			switch (this.input.LA(1)) {
				case PUBLIC :
					{
						alt207 = 1;
					}
					break;
				case PROTECTED :
					{
						alt207 = 2;
					}
					break;
				case INTERNAL :
					{
						alt207 = 3;
					}
					break;
				case PRIVATE :
					{
						alt207 = 4;
					}
					break;
				case EXTERN :
					{
						alt207 = 5;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 207, 0, this.input);

					throw nvae;
			}

			switch (alt207) {
				case 1 :
				// ../rsc/CSharp.g3:2137:9: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_constructormodifier13516);
						pUBLIC940 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC940.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2138:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_constructormodifier13526);
						pROTECTED941 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED941.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2139:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_constructormodifier13536);
						iNTERNAL942 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL942.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2140:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_constructormodifier13546);
						pRIVATE943 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE943.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2141:9: eXTERN
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_eXTERN_in_constructormodifier13556);
						eXTERN944 = eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, eXTERN944.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constructormodifier"

	public static class constructordeclarator_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constructordeclarator"
	// ../rsc/CSharp.g3:2145:1: constructordeclarator returns [String signature] : identifier lPAREN ( formalparameterlist )? rPAREN ( constructorinitializer )? -> identifier ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( constructorinitializer )? ;
	public final CSharpParser.constructordeclarator_return constructordeclarator()
			throws RecognitionException {
		CSharpParser.constructordeclarator_return retval =
			new CSharpParser.constructordeclarator_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier945 = null;

		CSharpParser.lPAREN_return lPAREN946 = null;

		CSharpParser.formalparameterlist_return formalparameterlist947 = null;

		CSharpParser.rPAREN_return rPAREN948 = null;

		CSharpParser.constructorinitializer_return constructorinitializer949 =
			null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_constructorinitializer =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constructorinitializer");
		RewriteRuleSubtreeStream stream_formalparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule formalparameterlist");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");

		String formalParams = "";

		try {
			// ../rsc/CSharp.g3:2149:5: ( identifier lPAREN ( formalparameterlist )? rPAREN ( constructorinitializer )? -> identifier ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( constructorinitializer )? )
			// ../rsc/CSharp.g3:2149:9: identifier lPAREN ( formalparameterlist )? rPAREN ( constructorinitializer )?
			{
				pushFollow(FOLLOW_identifier_in_constructordeclarator13585);
				identifier945 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier945.getTree());
				pushFollow(FOLLOW_lPAREN_in_constructordeclarator13592);
				lPAREN946 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN946.getTree());
				// ../rsc/CSharp.g3:2151:6: ( formalparameterlist )?
				int alt208 = 2;
				int LA208_0 = this.input.LA(1);

				if ((LA208_0 == LBRACKET || LA208_0 == BOOL || LA208_0 == BYTE
						|| LA208_0 == CHAR || LA208_0 == DECIMAL
						|| LA208_0 == DOUBLE || LA208_0 == FLOAT
						|| LA208_0 == INT || LA208_0 == LONG
						|| LA208_0 == OBJECT || LA208_0 == OUT
						|| LA208_0 == PARAMS || LA208_0 == REF
						|| LA208_0 == SBYTE || LA208_0 == SHORT
						|| LA208_0 == STRING
						|| (LA208_0 >= UINT && LA208_0 <= ULONG)
						|| LA208_0 == USHORT || (LA208_0 >= ADD && LA208_0 <= Ident))) {
					alt208 = 1;
				}
				switch (alt208) {
					case 1 :
					// ../rsc/CSharp.g3:2151:7: formalparameterlist
						{
							pushFollow(FOLLOW_formalparameterlist_in_constructordeclarator13600);
							formalparameterlist947 = formalparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_formalparameterlist
									.add(formalparameterlist947.getTree());
							if (this.state.backtracking == 0) {
								formalParams =
									(formalparameterlist947 != null ? formalparameterlist947.signature
											: null);
							}

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_constructordeclarator13611);
				rPAREN948 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN948.getTree());
				// ../rsc/CSharp.g3:2152:13: ( constructorinitializer )?
				int alt209 = 2;
				int LA209_0 = this.input.LA(1);

				if ((LA209_0 == COLON)) {
					alt209 = 1;
				}
				switch (alt209) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: constructorinitializer
						{
							pushFollow(FOLLOW_constructorinitializer_in_constructordeclarator13613);
							constructorinitializer949 =
								constructorinitializer();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_constructorinitializer
									.add(constructorinitializer949.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {
					retval.signature =
						(identifier945 != null ? identifier945.content : null)
								+ '(' + formalParams + ')';
				}

				// AST REWRITE
				// elements: constructorinitializer, lPAREN, identifier, rPAREN, formalparameterlist
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2154:5: -> identifier ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( constructorinitializer )?
					{
						this.adaptor.addChild(root_0, stream_identifier.nextTree());
						// ../rsc/CSharp.g3:2154:19: ^( ParameterList lPAREN ( formalparameterlist )? rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										ParameterList,
										"ParameterList"),
									root_1);

							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							// ../rsc/CSharp.g3:2154:42: ( formalparameterlist )?
							if (stream_formalparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_formalparameterlist.nextTree());

							}
							stream_formalparameterlist.reset();
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}
						// ../rsc/CSharp.g3:2154:71: ( constructorinitializer )?
						if (stream_constructorinitializer.hasNext()) {
							this.adaptor.addChild(
								root_0,
								stream_constructorinitializer.nextTree());

						}
						stream_constructorinitializer.reset();

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constructordeclarator"

	public static class constructorinitializer_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constructorinitializer"
	// ../rsc/CSharp.g3:2157:1: constructorinitializer : ( cOLON bASE lPAREN ( argumentlist )? rPAREN -> ^( BaseInitializer cOLON bASE lPAREN ( argumentlist )? rPAREN ) | cOLON tHIS lPAREN ( argumentlist )? rPAREN -> ^( ThisInitializer cOLON tHIS lPAREN ( argumentlist )? rPAREN ) );
	public final CSharpParser.constructorinitializer_return constructorinitializer()
			throws RecognitionException {
		CSharpParser.constructorinitializer_return retval =
			new CSharpParser.constructorinitializer_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cOLON_return cOLON950 = null;

		CSharpParser.bASE_return bASE951 = null;

		CSharpParser.lPAREN_return lPAREN952 = null;

		CSharpParser.argumentlist_return argumentlist953 = null;

		CSharpParser.rPAREN_return rPAREN954 = null;

		CSharpParser.cOLON_return cOLON955 = null;

		CSharpParser.tHIS_return tHIS956 = null;

		CSharpParser.lPAREN_return lPAREN957 = null;

		CSharpParser.argumentlist_return argumentlist958 = null;

		CSharpParser.rPAREN_return rPAREN959 = null;

		RewriteRuleSubtreeStream stream_tHIS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule tHIS");
		RewriteRuleSubtreeStream stream_cOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOLON");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_bASE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule bASE");
		RewriteRuleSubtreeStream stream_argumentlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule argumentlist");
		try {
			// ../rsc/CSharp.g3:2158:5: ( cOLON bASE lPAREN ( argumentlist )? rPAREN -> ^( BaseInitializer cOLON bASE lPAREN ( argumentlist )? rPAREN ) | cOLON tHIS lPAREN ( argumentlist )? rPAREN -> ^( ThisInitializer cOLON tHIS lPAREN ( argumentlist )? rPAREN ) )
			int alt212 = 2;
			alt212 = this.dfa212.predict(this.input);
			switch (alt212) {
				case 1 :
				// ../rsc/CSharp.g3:2158:9: cOLON bASE lPAREN ( argumentlist )? rPAREN
					{
						pushFollow(FOLLOW_cOLON_in_constructorinitializer13662);
						cOLON950 = cOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOLON.add(cOLON950.getTree());
						pushFollow(FOLLOW_bASE_in_constructorinitializer13664);
						bASE951 = bASE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_bASE.add(bASE951.getTree());
						pushFollow(FOLLOW_lPAREN_in_constructorinitializer13666);
						lPAREN952 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN952.getTree());
						// ../rsc/CSharp.g3:2158:27: ( argumentlist )?
						int alt210 = 2;
						int LA210_0 = this.input.LA(1);

						if ((LA210_0 == LPAREN
								|| (LA210_0 >= PLUS && LA210_0 <= MINUS)
								|| (LA210_0 >= EXCLAM && LA210_0 <= TILDE)
								|| (LA210_0 >= INCREMENT && LA210_0 <= DECREMENT)
								|| (LA210_0 >= BASE && LA210_0 <= BOOL)
								|| LA210_0 == BYTE
								|| (LA210_0 >= CHAR && LA210_0 <= CHECKED)
								|| (LA210_0 >= DECIMAL && LA210_0 <= DELEGATE)
								|| LA210_0 == DOUBLE || LA210_0 == FALSE
								|| LA210_0 == FLOAT || LA210_0 == INT
								|| LA210_0 == LONG
								|| (LA210_0 >= NEW && LA210_0 <= OBJECT)
								|| LA210_0 == OUT || LA210_0 == REF
								|| LA210_0 == SBYTE || LA210_0 == SHORT
								|| LA210_0 == STRING || LA210_0 == THIS
								|| LA210_0 == TRUE
								|| (LA210_0 >= TYPEOF && LA210_0 <= UNCHECKED)
								|| LA210_0 == USHORT || (LA210_0 >= ADD && LA210_0 <= Stringliteral))) {
							alt210 = 1;
						}
						switch (alt210) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: argumentlist
								{
									pushFollow(FOLLOW_argumentlist_in_constructorinitializer13668);
									argumentlist953 = argumentlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_argumentlist.add(argumentlist953
											.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_rPAREN_in_constructorinitializer13671);
						rPAREN954 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN954.getTree());

						// AST REWRITE
						// elements: argumentlist, lPAREN, rPAREN, cOLON, bASE
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2159:5: -> ^( BaseInitializer cOLON bASE lPAREN ( argumentlist )? rPAREN )
							{
								// ../rsc/CSharp.g3:2159:8: ^( BaseInitializer cOLON bASE lPAREN ( argumentlist )? rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												BaseInitializer,
												"BaseInitializer"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_cOLON.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_bASE.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									// ../rsc/CSharp.g3:2159:44: ( argumentlist )?
									if (stream_argumentlist.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_argumentlist.nextTree());

									}
									stream_argumentlist.reset();
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2160:9: cOLON tHIS lPAREN ( argumentlist )? rPAREN
					{
						pushFollow(FOLLOW_cOLON_in_constructorinitializer13702);
						cOLON955 = cOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOLON.add(cOLON955.getTree());
						pushFollow(FOLLOW_tHIS_in_constructorinitializer13704);
						tHIS956 = tHIS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_tHIS.add(tHIS956.getTree());
						pushFollow(FOLLOW_lPAREN_in_constructorinitializer13706);
						lPAREN957 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN957.getTree());
						// ../rsc/CSharp.g3:2160:27: ( argumentlist )?
						int alt211 = 2;
						int LA211_0 = this.input.LA(1);

						if ((LA211_0 == LPAREN
								|| (LA211_0 >= PLUS && LA211_0 <= MINUS)
								|| (LA211_0 >= EXCLAM && LA211_0 <= TILDE)
								|| (LA211_0 >= INCREMENT && LA211_0 <= DECREMENT)
								|| (LA211_0 >= BASE && LA211_0 <= BOOL)
								|| LA211_0 == BYTE
								|| (LA211_0 >= CHAR && LA211_0 <= CHECKED)
								|| (LA211_0 >= DECIMAL && LA211_0 <= DELEGATE)
								|| LA211_0 == DOUBLE || LA211_0 == FALSE
								|| LA211_0 == FLOAT || LA211_0 == INT
								|| LA211_0 == LONG
								|| (LA211_0 >= NEW && LA211_0 <= OBJECT)
								|| LA211_0 == OUT || LA211_0 == REF
								|| LA211_0 == SBYTE || LA211_0 == SHORT
								|| LA211_0 == STRING || LA211_0 == THIS
								|| LA211_0 == TRUE
								|| (LA211_0 >= TYPEOF && LA211_0 <= UNCHECKED)
								|| LA211_0 == USHORT || (LA211_0 >= ADD && LA211_0 <= Stringliteral))) {
							alt211 = 1;
						}
						switch (alt211) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: argumentlist
								{
									pushFollow(FOLLOW_argumentlist_in_constructorinitializer13708);
									argumentlist958 = argumentlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_argumentlist.add(argumentlist958
											.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_rPAREN_in_constructorinitializer13711);
						rPAREN959 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN959.getTree());

						// AST REWRITE
						// elements: cOLON, rPAREN, argumentlist, lPAREN, tHIS
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2161:5: -> ^( ThisInitializer cOLON tHIS lPAREN ( argumentlist )? rPAREN )
							{
								// ../rsc/CSharp.g3:2161:8: ^( ThisInitializer cOLON tHIS lPAREN ( argumentlist )? rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ThisInitializer,
												"ThisInitializer"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_cOLON.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_tHIS.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									// ../rsc/CSharp.g3:2161:44: ( argumentlist )?
									if (stream_argumentlist.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_argumentlist.nextTree());

									}
									stream_argumentlist.reset();
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constructorinitializer"

	public static class constructorbody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constructorbody"
	// ../rsc/CSharp.g3:2164:1: constructorbody : ( block | sEMICOLON );
	public final CSharpParser.constructorbody_return constructorbody()
			throws RecognitionException {
		CSharpParser.constructorbody_return retval =
			new CSharpParser.constructorbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.block_return block960 = null;

		CSharpParser.sEMICOLON_return sEMICOLON961 = null;

		try {
			// ../rsc/CSharp.g3:2165:5: ( block | sEMICOLON )
			int alt213 = 2;
			int LA213_0 = this.input.LA(1);

			if ((LA213_0 == LBRACE)) {
				alt213 = 1;
			}
			else if ((LA213_0 == SEMICOLON)) {
				alt213 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 213, 0, this.input);

				throw nvae;
			}
			switch (alt213) {
				case 1 :
				// ../rsc/CSharp.g3:2165:9: block
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_block_in_constructorbody13751);
						block960 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, block960.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2166:9: sEMICOLON
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEMICOLON_in_constructorbody13761);
						sEMICOLON961 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEMICOLON961.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constructorbody"

	public static class staticconstructordeclaration_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "staticconstructordeclaration"
	// ../rsc/CSharp.g3:2169:1: staticconstructordeclaration returns [String signature] : ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN staticconstructorbody -> ^( StaticConstructor ( attributes )? staticconstructormodifiers identifier ^( ParameterList lPAREN rPAREN ) staticconstructorbody ) ;
	public final CSharpParser.staticconstructordeclaration_return staticconstructordeclaration()
			throws RecognitionException {
		CSharpParser.staticconstructordeclaration_return retval =
			new CSharpParser.staticconstructordeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes962 = null;

		CSharpParser.staticconstructormodifiers_return staticconstructormodifiers963 =
			null;

		CSharpParser.identifier_return identifier964 = null;

		CSharpParser.lPAREN_return lPAREN965 = null;

		CSharpParser.rPAREN_return rPAREN966 = null;

		CSharpParser.staticconstructorbody_return staticconstructorbody967 =
			null;

		RewriteRuleSubtreeStream stream_staticconstructormodifiers =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule staticconstructormodifiers");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_staticconstructorbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule staticconstructorbody");
		try {
			// ../rsc/CSharp.g3:2173:5: ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN staticconstructorbody -> ^( StaticConstructor ( attributes )? staticconstructormodifiers identifier ^( ParameterList lPAREN rPAREN ) staticconstructorbody ) )
			// ../rsc/CSharp.g3:2173:9: ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN staticconstructorbody
			{
				// ../rsc/CSharp.g3:2173:9: ( attributes )?
				int alt214 = 2;
				int LA214_0 = this.input.LA(1);

				if ((LA214_0 == LBRACKET)) {
					alt214 = 1;
				}
				switch (alt214) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_staticconstructordeclaration13789);
							attributes962 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes962.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_staticconstructormodifiers_in_staticconstructordeclaration13792);
				staticconstructormodifiers963 = staticconstructormodifiers();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_staticconstructormodifiers
						.add(staticconstructormodifiers963.getTree());
				pushFollow(FOLLOW_identifier_in_staticconstructordeclaration13794);
				identifier964 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier964.getTree());
				pushFollow(FOLLOW_lPAREN_in_staticconstructordeclaration13796);
				lPAREN965 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN965.getTree());
				pushFollow(FOLLOW_rPAREN_in_staticconstructordeclaration13798);
				rPAREN966 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN966.getTree());
				pushFollow(FOLLOW_staticconstructorbody_in_staticconstructordeclaration13800);
				staticconstructorbody967 = staticconstructorbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_staticconstructorbody.add(staticconstructorbody967
						.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(identifier964 != null ? identifier964.content : null)
								+ "()";
				}

				// AST REWRITE
				// elements: lPAREN, rPAREN, staticconstructormodifiers, identifier, staticconstructorbody, attributes
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2175:5: -> ^( StaticConstructor ( attributes )? staticconstructormodifiers identifier ^( ParameterList lPAREN rPAREN ) staticconstructorbody )
					{
						// ../rsc/CSharp.g3:2175:8: ^( StaticConstructor ( attributes )? staticconstructormodifiers identifier ^( ParameterList lPAREN rPAREN ) staticconstructorbody )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										StaticConstructor,
										"StaticConstructor"), root_1);

							// ../rsc/CSharp.g3:2175:28: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							this.adaptor.addChild(
								root_1,
								stream_staticconstructormodifiers.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:2176:6: ^( ParameterList lPAREN rPAREN )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											ParameterList,
											"ParameterList"),
										root_2);

								this.adaptor.addChild(
									root_2,
									stream_lPAREN.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_rPAREN.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}
							this.adaptor.addChild(
								root_1,
								stream_staticconstructorbody.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.signature);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "staticconstructordeclaration"

	public static class staticconstructormodifiers_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "staticconstructormodifiers"
	// ../rsc/CSharp.g3:2179:1: staticconstructormodifiers : ( ( eXTERN )? sTATIC -> ^( Modifiers ( eXTERN )? sTATIC ) | sTATIC ( eXTERN )? -> ^( Modifiers sTATIC ( eXTERN )? ) );
	public final CSharpParser.staticconstructormodifiers_return staticconstructormodifiers()
			throws RecognitionException {
		CSharpParser.staticconstructormodifiers_return retval =
			new CSharpParser.staticconstructormodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.eXTERN_return eXTERN968 = null;

		CSharpParser.sTATIC_return sTATIC969 = null;

		CSharpParser.sTATIC_return sTATIC970 = null;

		CSharpParser.eXTERN_return eXTERN971 = null;

		RewriteRuleSubtreeStream stream_sTATIC =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sTATIC");
		RewriteRuleSubtreeStream stream_eXTERN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eXTERN");
		try {
			// ../rsc/CSharp.g3:2180:5: ( ( eXTERN )? sTATIC -> ^( Modifiers ( eXTERN )? sTATIC ) | sTATIC ( eXTERN )? -> ^( Modifiers sTATIC ( eXTERN )? ) )
			int alt217 = 2;
			int LA217_0 = this.input.LA(1);

			if ((LA217_0 == EXTERN)) {
				alt217 = 1;
			}
			else if ((LA217_0 == STATIC)) {
				this.input.LA(2);

				if ((synpred521_CSharp())) {
					alt217 = 1;
				}
				else if ((true)) {
					alt217 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 217, 0, this.input);

				throw nvae;
			}
			switch (alt217) {
				case 1 :
				// ../rsc/CSharp.g3:2180:9: ( eXTERN )? sTATIC
					{
						// ../rsc/CSharp.g3:2180:9: ( eXTERN )?
						int alt215 = 2;
						int LA215_0 = this.input.LA(1);

						if ((LA215_0 == EXTERN)) {
							alt215 = 1;
						}
						switch (alt215) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: eXTERN
								{
									pushFollow(FOLLOW_eXTERN_in_staticconstructormodifiers13858);
									eXTERN968 = eXTERN();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_eXTERN.add(eXTERN968.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_sTATIC_in_staticconstructormodifiers13861);
						sTATIC969 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sTATIC.add(sTATIC969.getTree());

						// AST REWRITE
						// elements: eXTERN, sTATIC
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2181:5: -> ^( Modifiers ( eXTERN )? sTATIC )
							{
								// ../rsc/CSharp.g3:2181:8: ^( Modifiers ( eXTERN )? sTATIC )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_1);

									// ../rsc/CSharp.g3:2181:20: ( eXTERN )?
									if (stream_eXTERN.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_eXTERN.nextTree());

									}
									stream_eXTERN.reset();
									this.adaptor.addChild(
										root_1,
										stream_sTATIC.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2182:9: sTATIC ( eXTERN )?
					{
						pushFollow(FOLLOW_sTATIC_in_staticconstructormodifiers13886);
						sTATIC970 = sTATIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sTATIC.add(sTATIC970.getTree());
						// ../rsc/CSharp.g3:2182:16: ( eXTERN )?
						int alt216 = 2;
						int LA216_0 = this.input.LA(1);

						if ((LA216_0 == EXTERN)) {
							alt216 = 1;
						}
						switch (alt216) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: eXTERN
								{
									pushFollow(FOLLOW_eXTERN_in_staticconstructormodifiers13888);
									eXTERN971 = eXTERN();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_eXTERN.add(eXTERN971.getTree());

								}
								break;

						}

						// AST REWRITE
						// elements: sTATIC, eXTERN
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2183:5: -> ^( Modifiers sTATIC ( eXTERN )? )
							{
								// ../rsc/CSharp.g3:2183:9: ^( Modifiers sTATIC ( eXTERN )? )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_sTATIC.nextTree());
									// ../rsc/CSharp.g3:2183:28: ( eXTERN )?
									if (stream_eXTERN.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_eXTERN.nextTree());

									}
									stream_eXTERN.reset();

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "staticconstructormodifiers"

	public static class staticconstructorbody_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "staticconstructorbody"
	// ../rsc/CSharp.g3:2186:1: staticconstructorbody : ( block | sEMICOLON );
	public final CSharpParser.staticconstructorbody_return staticconstructorbody()
			throws RecognitionException {
		CSharpParser.staticconstructorbody_return retval =
			new CSharpParser.staticconstructorbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.block_return block972 = null;

		CSharpParser.sEMICOLON_return sEMICOLON973 = null;

		try {
			// ../rsc/CSharp.g3:2187:5: ( block | sEMICOLON )
			int alt218 = 2;
			int LA218_0 = this.input.LA(1);

			if ((LA218_0 == LBRACE)) {
				alt218 = 1;
			}
			else if ((LA218_0 == SEMICOLON)) {
				alt218 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 218, 0, this.input);

				throw nvae;
			}
			switch (alt218) {
				case 1 :
				// ../rsc/CSharp.g3:2187:9: block
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_block_in_staticconstructorbody13924);
						block972 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, block972.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2188:9: sEMICOLON
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEMICOLON_in_staticconstructorbody13934);
						sEMICOLON973 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEMICOLON973.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "staticconstructorbody"

	public static class finalizerdeclaration_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "finalizerdeclaration"
	// ../rsc/CSharp.g3:2191:1: finalizerdeclaration returns [String signature] : ( attributes )? ( eXTERN )? tILDE identifier lPAREN rPAREN finalizerbody -> ^( Finalizer ( attributes )? ( ^( Modifiers eXTERN ) )? tILDE identifier ^( ParameterList lPAREN rPAREN ) finalizerbody ) ;
	public final CSharpParser.finalizerdeclaration_return finalizerdeclaration()
			throws RecognitionException {
		CSharpParser.finalizerdeclaration_return retval =
			new CSharpParser.finalizerdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes974 = null;

		CSharpParser.eXTERN_return eXTERN975 = null;

		CSharpParser.tILDE_return tILDE976 = null;

		CSharpParser.identifier_return identifier977 = null;

		CSharpParser.lPAREN_return lPAREN978 = null;

		CSharpParser.rPAREN_return rPAREN979 = null;

		CSharpParser.finalizerbody_return finalizerbody980 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_finalizerbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule finalizerbody");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_eXTERN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eXTERN");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_tILDE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule tILDE");
		try {
			// ../rsc/CSharp.g3:2195:5: ( ( attributes )? ( eXTERN )? tILDE identifier lPAREN rPAREN finalizerbody -> ^( Finalizer ( attributes )? ( ^( Modifiers eXTERN ) )? tILDE identifier ^( ParameterList lPAREN rPAREN ) finalizerbody ) )
			// ../rsc/CSharp.g3:2195:9: ( attributes )? ( eXTERN )? tILDE identifier lPAREN rPAREN finalizerbody
			{
				// ../rsc/CSharp.g3:2195:9: ( attributes )?
				int alt219 = 2;
				int LA219_0 = this.input.LA(1);

				if ((LA219_0 == LBRACKET)) {
					alt219 = 1;
				}
				switch (alt219) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_finalizerdeclaration13962);
							attributes974 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes974.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2195:21: ( eXTERN )?
				int alt220 = 2;
				int LA220_0 = this.input.LA(1);

				if ((LA220_0 == EXTERN)) {
					alt220 = 1;
				}
				switch (alt220) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: eXTERN
						{
							pushFollow(FOLLOW_eXTERN_in_finalizerdeclaration13965);
							eXTERN975 = eXTERN();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_eXTERN.add(eXTERN975.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_tILDE_in_finalizerdeclaration13968);
				tILDE976 = tILDE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_tILDE.add(tILDE976.getTree());
				pushFollow(FOLLOW_identifier_in_finalizerdeclaration13970);
				identifier977 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier977.getTree());
				pushFollow(FOLLOW_lPAREN_in_finalizerdeclaration13972);
				lPAREN978 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN978.getTree());
				pushFollow(FOLLOW_rPAREN_in_finalizerdeclaration13974);
				rPAREN979 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN979.getTree());
				pushFollow(FOLLOW_finalizerbody_in_finalizerdeclaration13976);
				finalizerbody980 = finalizerbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_finalizerbody.add(finalizerbody980.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						"~"
								+ (identifier977 != null ? identifier977.content
										: null) + "()";
				}

				// AST REWRITE
				// elements: tILDE, eXTERN, finalizerbody, identifier, attributes, lPAREN, rPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2197:5: -> ^( Finalizer ( attributes )? ( ^( Modifiers eXTERN ) )? tILDE identifier ^( ParameterList lPAREN rPAREN ) finalizerbody )
					{
						// ../rsc/CSharp.g3:2197:8: ^( Finalizer ( attributes )? ( ^( Modifiers eXTERN ) )? tILDE identifier ^( ParameterList lPAREN rPAREN ) finalizerbody )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Finalizer, "Finalizer"), root_1);

							// ../rsc/CSharp.g3:2197:20: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2197:32: ( ^( Modifiers eXTERN ) )?
							if (stream_eXTERN.hasNext()) {
								// ../rsc/CSharp.g3:2197:32: ^( Modifiers eXTERN )
								{
									Object root_2 = (Object) this.adaptor.nil();
									root_2 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_2);

									this.adaptor.addChild(
										root_2,
										stream_eXTERN.nextTree());

									this.adaptor.addChild(root_1, root_2);
								}

							}
							stream_eXTERN.reset();
							this.adaptor.addChild(root_1, stream_tILDE.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:2197:70: ^( ParameterList lPAREN rPAREN )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											ParameterList,
											"ParameterList"),
										root_2);

								this.adaptor.addChild(
									root_2,
									stream_lPAREN.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_rPAREN.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}
							this.adaptor.addChild(
								root_1,
								stream_finalizerbody.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.signature);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "finalizerdeclaration"

	public static class finalizerbody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "finalizerbody"
	// ../rsc/CSharp.g3:2200:1: finalizerbody : ( block | sEMICOLON );
	public final CSharpParser.finalizerbody_return finalizerbody()
			throws RecognitionException {
		CSharpParser.finalizerbody_return retval =
			new CSharpParser.finalizerbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.block_return block981 = null;

		CSharpParser.sEMICOLON_return sEMICOLON982 = null;

		try {
			// ../rsc/CSharp.g3:2201:5: ( block | sEMICOLON )
			int alt221 = 2;
			int LA221_0 = this.input.LA(1);

			if ((LA221_0 == LBRACE)) {
				alt221 = 1;
			}
			else if ((LA221_0 == SEMICOLON)) {
				alt221 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 221, 0, this.input);

				throw nvae;
			}
			switch (alt221) {
				case 1 :
				// ../rsc/CSharp.g3:2201:9: block
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_block_in_finalizerbody14036);
						block981 = block();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, block981.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2202:9: sEMICOLON
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_sEMICOLON_in_finalizerbody14046);
						sEMICOLON982 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, sEMICOLON982.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "finalizerbody"

	public static class structdeclaration_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "structdeclaration"
	// ../rsc/CSharp.g3:2207:1: structdeclaration returns [String name] : ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT identifier ( typeparameterlist )? ( structinterfaces )? ( typeparameterconstraintsclauses )? structbody ( sEMICOLON )? -> ^( Struct ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT identifier ( typeparameterlist )? ( structinterfaces )? ( typeparameterconstraintsclauses )? structbody ( sEMICOLON )? ) ;
	public final CSharpParser.structdeclaration_return structdeclaration()
			throws RecognitionException {
		CSharpParser.structdeclaration_return retval =
			new CSharpParser.structdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes983 = null;

		CSharpParser.structmodifiers_return structmodifiers984 = null;

		CSharpParser.pARTIAL_return pARTIAL985 = null;

		CSharpParser.sTRUCT_return sTRUCT986 = null;

		CSharpParser.identifier_return identifier987 = null;

		CSharpParser.typeparameterlist_return typeparameterlist988 = null;

		CSharpParser.structinterfaces_return structinterfaces989 = null;

		CSharpParser.typeparameterconstraintsclauses_return typeparameterconstraintsclauses990 =
			null;

		CSharpParser.structbody_return structbody991 = null;

		CSharpParser.sEMICOLON_return sEMICOLON992 = null;

		RewriteRuleSubtreeStream stream_structmodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule structmodifiers");
		RewriteRuleSubtreeStream stream_pARTIAL =
			new RewriteRuleSubtreeStream(this.adaptor, "rule pARTIAL");
		RewriteRuleSubtreeStream stream_sTRUCT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sTRUCT");
		RewriteRuleSubtreeStream stream_typeparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameterlist");
		RewriteRuleSubtreeStream stream_typeparameterconstraintsclauses =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule typeparameterconstraintsclauses");
		RewriteRuleSubtreeStream stream_structbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule structbody");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_structinterfaces =
			new RewriteRuleSubtreeStream(this.adaptor, "rule structinterfaces");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:2211:5: ( ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT identifier ( typeparameterlist )? ( structinterfaces )? ( typeparameterconstraintsclauses )? structbody ( sEMICOLON )? -> ^( Struct ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT identifier ( typeparameterlist )? ( structinterfaces )? ( typeparameterconstraintsclauses )? structbody ( sEMICOLON )? ) )
			// ../rsc/CSharp.g3:2211:9: ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT identifier ( typeparameterlist )? ( structinterfaces )? ( typeparameterconstraintsclauses )? structbody ( sEMICOLON )?
			{
				// ../rsc/CSharp.g3:2211:9: ( attributes )?
				int alt222 = 2;
				int LA222_0 = this.input.LA(1);

				if ((LA222_0 == LBRACKET)) {
					alt222 = 1;
				}
				switch (alt222) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_structdeclaration14076);
							attributes983 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes983.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2211:21: ( structmodifiers )?
				int alt223 = 2;
				int LA223_0 = this.input.LA(1);

				if ((LA223_0 == INTERNAL || LA223_0 == NEW || (LA223_0 >= PRIVATE && LA223_0 <= PUBLIC))) {
					alt223 = 1;
				}
				switch (alt223) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: structmodifiers
						{
							pushFollow(FOLLOW_structmodifiers_in_structdeclaration14079);
							structmodifiers984 = structmodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_structmodifiers.add(structmodifiers984
									.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2211:38: ( pARTIAL )?
				int alt224 = 2;
				int LA224_0 = this.input.LA(1);

				if ((LA224_0 == PARTIAL)) {
					alt224 = 1;
				}
				switch (alt224) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: pARTIAL
						{
							pushFollow(FOLLOW_pARTIAL_in_structdeclaration14082);
							pARTIAL985 = pARTIAL();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_pARTIAL.add(pARTIAL985.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_sTRUCT_in_structdeclaration14085);
				sTRUCT986 = sTRUCT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sTRUCT.add(sTRUCT986.getTree());
				pushFollow(FOLLOW_identifier_in_structdeclaration14087);
				identifier987 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier987.getTree());
				// ../rsc/CSharp.g3:2211:65: ( typeparameterlist )?
				int alt225 = 2;
				int LA225_0 = this.input.LA(1);

				if ((LA225_0 == LT)) {
					alt225 = 1;
				}
				switch (alt225) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterlist
						{
							pushFollow(FOLLOW_typeparameterlist_in_structdeclaration14089);
							typeparameterlist988 = typeparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterlist
									.add(typeparameterlist988.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2212:7: ( structinterfaces )?
				int alt226 = 2;
				int LA226_0 = this.input.LA(1);

				if ((LA226_0 == COLON)) {
					alt226 = 1;
				}
				switch (alt226) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: structinterfaces
						{
							pushFollow(FOLLOW_structinterfaces_in_structdeclaration14098);
							structinterfaces989 = structinterfaces();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_structinterfaces.add(structinterfaces989
									.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2212:25: ( typeparameterconstraintsclauses )?
				int alt227 = 2;
				int LA227_0 = this.input.LA(1);

				if ((LA227_0 == WHERE)) {
					alt227 = 1;
				}
				switch (alt227) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterconstraintsclauses
						{
							pushFollow(FOLLOW_typeparameterconstraintsclauses_in_structdeclaration14101);
							typeparameterconstraintsclauses990 =
								typeparameterconstraintsclauses();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterconstraintsclauses
									.add(typeparameterconstraintsclauses990
										.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_structbody_in_structdeclaration14104);
				structbody991 = structbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_structbody.add(structbody991.getTree());
				// ../rsc/CSharp.g3:2212:69: ( sEMICOLON )?
				int alt228 = 2;
				int LA228_0 = this.input.LA(1);

				if ((LA228_0 == SEMICOLON)) {
					alt228 = 1;
				}
				switch (alt228) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: sEMICOLON
						{
							pushFollow(FOLLOW_sEMICOLON_in_structdeclaration14106);
							sEMICOLON992 = sEMICOLON();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_sEMICOLON.add(sEMICOLON992.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {
					retval.name =
						(identifier987 != null ? identifier987.content : null);
				}

				// AST REWRITE
				// elements: identifier, sTRUCT, structbody, structmodifiers, pARTIAL, typeparameterlist, sEMICOLON, attributes, structinterfaces, typeparameterconstraintsclauses
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2214:5: -> ^( Struct ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT identifier ( typeparameterlist )? ( structinterfaces )? ( typeparameterconstraintsclauses )? structbody ( sEMICOLON )? )
					{
						// ../rsc/CSharp.g3:2214:9: ^( Struct ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT identifier ( typeparameterlist )? ( structinterfaces )? ( typeparameterconstraintsclauses )? structbody ( sEMICOLON )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Struct, "Struct"),
									root_1);

							// ../rsc/CSharp.g3:2214:18: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2214:30: ( structmodifiers )?
							if (stream_structmodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_structmodifiers.nextTree());

							}
							stream_structmodifiers.reset();
							// ../rsc/CSharp.g3:2214:47: ( pARTIAL )?
							if (stream_pARTIAL.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_pARTIAL.nextTree());

							}
							stream_pARTIAL.reset();
							this.adaptor.addChild(root_1, stream_sTRUCT.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:2214:74: ( typeparameterlist )?
							if (stream_typeparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterlist.nextTree());

							}
							stream_typeparameterlist.reset();
							// ../rsc/CSharp.g3:2215:7: ( structinterfaces )?
							if (stream_structinterfaces.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_structinterfaces.nextTree());

							}
							stream_structinterfaces.reset();
							// ../rsc/CSharp.g3:2215:25: ( typeparameterconstraintsclauses )?
							if (stream_typeparameterconstraintsclauses
								.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterconstraintsclauses
										.nextTree());

							}
							stream_typeparameterconstraintsclauses.reset();
							this.adaptor.addChild(
								root_1,
								stream_structbody.nextTree());
							// ../rsc/CSharp.g3:2215:69: ( sEMICOLON )?
							if (stream_sEMICOLON.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_sEMICOLON.nextTree());

							}
							stream_sEMICOLON.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "structdeclaration"

	public static class structmodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "structmodifiers"
	// ../rsc/CSharp.g3:2220:1: structmodifiers : ( structmodifier )+ -> ^( Modifiers ( structmodifier )+ ) ;
	public final CSharpParser.structmodifiers_return structmodifiers()
			throws RecognitionException {
		CSharpParser.structmodifiers_return retval =
			new CSharpParser.structmodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.structmodifier_return structmodifier993 = null;

		RewriteRuleSubtreeStream stream_structmodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule structmodifier");
		try {
			// ../rsc/CSharp.g3:2221:5: ( ( structmodifier )+ -> ^( Modifiers ( structmodifier )+ ) )
			// ../rsc/CSharp.g3:2221:9: ( structmodifier )+
			{
				// ../rsc/CSharp.g3:2221:9: ( structmodifier )+
				int cnt229 = 0;
				loop229: do {
					int alt229 = 2;
					int LA229_0 = this.input.LA(1);

					if ((LA229_0 == INTERNAL || LA229_0 == NEW || (LA229_0 >= PRIVATE && LA229_0 <= PUBLIC))) {
						alt229 = 1;
					}

					switch (alt229) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: structmodifier
							{
								pushFollow(FOLLOW_structmodifier_in_structmodifiers14180);
								structmodifier993 = structmodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_structmodifier.add(structmodifier993
										.getTree());

							}
							break;

						default :
							if (cnt229 >= 1)
								break loop229;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(229, this.input);
							throw eee;
					}
					cnt229++;
				}
				while (true);

				// AST REWRITE
				// elements: structmodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2222:5: -> ^( Modifiers ( structmodifier )+ )
					{
						// ../rsc/CSharp.g3:2222:8: ^( Modifiers ( structmodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_structmodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_structmodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_structmodifier.nextTree());

							}
							stream_structmodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "structmodifiers"

	public static class structmodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "structmodifier"
	// ../rsc/CSharp.g3:2225:1: structmodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE );
	public final CSharpParser.structmodifier_return structmodifier()
			throws RecognitionException {
		CSharpParser.structmodifier_return retval =
			new CSharpParser.structmodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW994 = null;

		CSharpParser.pUBLIC_return pUBLIC995 = null;

		CSharpParser.pROTECTED_return pROTECTED996 = null;

		CSharpParser.iNTERNAL_return iNTERNAL997 = null;

		CSharpParser.pRIVATE_return pRIVATE998 = null;

		try {
			// ../rsc/CSharp.g3:2226:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE )
			int alt230 = 5;
			switch (this.input.LA(1)) {
				case NEW :
					{
						alt230 = 1;
					}
					break;
				case PUBLIC :
					{
						alt230 = 2;
					}
					break;
				case PROTECTED :
					{
						alt230 = 3;
					}
					break;
				case INTERNAL :
					{
						alt230 = 4;
					}
					break;
				case PRIVATE :
					{
						alt230 = 5;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 230, 0, this.input);

					throw nvae;
			}

			switch (alt230) {
				case 1 :
				// ../rsc/CSharp.g3:2226:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_structmodifier14213);
						nEW994 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW994.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2227:10: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_structmodifier14224);
						pUBLIC995 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC995.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2228:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_structmodifier14234);
						pROTECTED996 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED996.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2229:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_structmodifier14244);
						iNTERNAL997 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL997.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2230:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_structmodifier14254);
						pRIVATE998 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE998.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "structmodifier"

	public static class structinterfaces_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "structinterfaces"
	// ../rsc/CSharp.g3:2233:1: structinterfaces : cOLON interfacetypelist ;
	public final CSharpParser.structinterfaces_return structinterfaces()
			throws RecognitionException {
		CSharpParser.structinterfaces_return retval =
			new CSharpParser.structinterfaces_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cOLON_return cOLON999 = null;

		CSharpParser.interfacetypelist_return interfacetypelist1000 = null;

		try {
			// ../rsc/CSharp.g3:2234:5: ( cOLON interfacetypelist )
			// ../rsc/CSharp.g3:2234:9: cOLON interfacetypelist
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_cOLON_in_structinterfaces14273);
				cOLON999 = cOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, cOLON999.getTree());
				pushFollow(FOLLOW_interfacetypelist_in_structinterfaces14275);
				interfacetypelist1000 = interfacetypelist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, interfacetypelist1000.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "structinterfaces"

	public static class structbody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "structbody"
	// ../rsc/CSharp.g3:2237:1: structbody : lBRACE ( structmemberdeclaration )* rBRACE -> ^( Body lBRACE ( structmemberdeclaration )* rBRACE ) ;
	public final CSharpParser.structbody_return structbody()
			throws RecognitionException {
		CSharpParser.structbody_return retval =
			new CSharpParser.structbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACE_return lBRACE1001 = null;

		CSharpParser.structmemberdeclaration_return structmemberdeclaration1002 =
			null;

		CSharpParser.rBRACE_return rBRACE1003 = null;

		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_structmemberdeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule structmemberdeclaration");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:2238:5: ( lBRACE ( structmemberdeclaration )* rBRACE -> ^( Body lBRACE ( structmemberdeclaration )* rBRACE ) )
			// ../rsc/CSharp.g3:2238:9: lBRACE ( structmemberdeclaration )* rBRACE
			{
				pushFollow(FOLLOW_lBRACE_in_structbody14294);
				lBRACE1001 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE1001.getTree());
				// ../rsc/CSharp.g3:2238:16: ( structmemberdeclaration )*
				loop231: do {
					int alt231 = 2;
					int LA231_0 = this.input.LA(1);

					if ((LA231_0 == LBRACKET || LA231_0 == ABSTRACT
							|| LA231_0 == BOOL || LA231_0 == BYTE
							|| LA231_0 == CHAR
							|| (LA231_0 >= CLASS && LA231_0 <= CONST)
							|| LA231_0 == DECIMAL || LA231_0 == DELEGATE
							|| LA231_0 == DOUBLE
							|| (LA231_0 >= ENUM && LA231_0 <= EVENT)
							|| LA231_0 == EXTERN || LA231_0 == FLOAT
							|| (LA231_0 >= INT && LA231_0 <= INTERNAL)
							|| LA231_0 == LONG || LA231_0 == NEW
							|| LA231_0 == OBJECT || LA231_0 == OVERRIDE
							|| (LA231_0 >= PRIVATE && LA231_0 <= READONLY)
							|| (LA231_0 >= SBYTE && LA231_0 <= SHORT)
							|| (LA231_0 >= STATIC && LA231_0 <= STRUCT)
							|| (LA231_0 >= UINT && LA231_0 <= ULONG)
							|| LA231_0 == USHORT
							|| (LA231_0 >= VIRTUAL && LA231_0 <= VOLATILE) || (LA231_0 >= ADD && LA231_0 <= Ident))) {
						alt231 = 1;
					}

					switch (alt231) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: structmemberdeclaration
							{
								pushFollow(FOLLOW_structmemberdeclaration_in_structbody14296);
								structmemberdeclaration1002 =
									structmemberdeclaration();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_structmemberdeclaration
										.add(structmemberdeclaration1002
											.getTree());

							}
							break;

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

				pushFollow(FOLLOW_rBRACE_in_structbody14299);
				rBRACE1003 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE1003.getTree());

				// AST REWRITE
				// elements: structmemberdeclaration, rBRACE, lBRACE
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2239:5: -> ^( Body lBRACE ( structmemberdeclaration )* rBRACE )
					{
						// ../rsc/CSharp.g3:2239:8: ^( Body lBRACE ( structmemberdeclaration )* rBRACE )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Body, "Body"),
									root_1);

							this.adaptor.addChild(root_1, stream_lBRACE.nextTree());
							// ../rsc/CSharp.g3:2239:22: ( structmemberdeclaration )*
							while (stream_structmemberdeclaration.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_structmemberdeclaration.nextTree());

							}
							stream_structmemberdeclaration.reset();
							this.adaptor.addChild(root_1, stream_rBRACE.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "structbody"

	public static class structmemberdeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "structmemberdeclaration"
	// ../rsc/CSharp.g3:2243:1: structmemberdeclaration : ( ( ( attributes )? ( constantmodifiers )? cONST )=> constantdeclaration -> ^( StructMemberDeclaration constantdeclaration ) | fielddeclaration -> ^( StructMemberDeclaration fielddeclaration ) | ( methodheader )=> methoddeclaration -> ^( StructMemberDeclaration methoddeclaration ) | propertydeclaration -> ^( StructMemberDeclaration propertydeclaration ) | ( ( attributes )? ( eventmodifiers )? eVENT )=> eventdeclaration -> ^( StructMemberDeclaration eventdeclaration ) | ( ( attributes )? ( indexermodifiers )? indexerdeclarator )=> indexerdeclaration -> ^( StructMemberDeclaration indexerdeclaration ) | ( ( attributes )? operatormodifiers operatordeclarator )=> operatordeclaration -> ^( StructMemberDeclaration operatordeclaration ) | ( ( attributes )? ( constructormodifiers )? constructordeclarator )=> constructordeclaration -> ^( StructMemberDeclaration constructordeclaration ) | ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )=> staticconstructordeclaration -> ^( StructMemberDeclaration staticconstructordeclaration ) | typedeclaration -> ^( StructMemberDeclaration typedeclaration ) );
	public final CSharpParser.structmemberdeclaration_return structmemberdeclaration()
			throws RecognitionException {
		CSharpParser.structmemberdeclaration_return retval =
			new CSharpParser.structmemberdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.constantdeclaration_return constantdeclaration1004 = null;

		CSharpParser.fielddeclaration_return fielddeclaration1005 = null;

		CSharpParser.methoddeclaration_return methoddeclaration1006 = null;

		CSharpParser.propertydeclaration_return propertydeclaration1007 = null;

		CSharpParser.eventdeclaration_return eventdeclaration1008 = null;

		CSharpParser.indexerdeclaration_return indexerdeclaration1009 = null;

		CSharpParser.operatordeclaration_return operatordeclaration1010 = null;

		CSharpParser.constructordeclaration_return constructordeclaration1011 =
			null;

		CSharpParser.staticconstructordeclaration_return staticconstructordeclaration1012 =
			null;

		CSharpParser.typedeclaration_return typedeclaration1013 = null;

		RewriteRuleSubtreeStream stream_operatordeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule operatordeclaration");
		RewriteRuleSubtreeStream stream_propertydeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule propertydeclaration");
		RewriteRuleSubtreeStream stream_constantdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantdeclaration");
		RewriteRuleSubtreeStream stream_eventdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eventdeclaration");
		RewriteRuleSubtreeStream stream_fielddeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule fielddeclaration");
		RewriteRuleSubtreeStream stream_methoddeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule methoddeclaration");
		RewriteRuleSubtreeStream stream_staticconstructordeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule staticconstructordeclaration");
		RewriteRuleSubtreeStream stream_indexerdeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule indexerdeclaration");
		RewriteRuleSubtreeStream stream_typedeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typedeclaration");
		RewriteRuleSubtreeStream stream_constructordeclaration =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constructordeclaration");
		try {
			// ../rsc/CSharp.g3:2244:5: ( ( ( attributes )? ( constantmodifiers )? cONST )=> constantdeclaration -> ^( StructMemberDeclaration constantdeclaration ) | fielddeclaration -> ^( StructMemberDeclaration fielddeclaration ) | ( methodheader )=> methoddeclaration -> ^( StructMemberDeclaration methoddeclaration ) | propertydeclaration -> ^( StructMemberDeclaration propertydeclaration ) | ( ( attributes )? ( eventmodifiers )? eVENT )=> eventdeclaration -> ^( StructMemberDeclaration eventdeclaration ) | ( ( attributes )? ( indexermodifiers )? indexerdeclarator )=> indexerdeclaration -> ^( StructMemberDeclaration indexerdeclaration ) | ( ( attributes )? operatormodifiers operatordeclarator )=> operatordeclaration -> ^( StructMemberDeclaration operatordeclaration ) | ( ( attributes )? ( constructormodifiers )? constructordeclarator )=> constructordeclaration -> ^( StructMemberDeclaration constructordeclaration ) | ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )=> staticconstructordeclaration -> ^( StructMemberDeclaration staticconstructordeclaration ) | typedeclaration -> ^( StructMemberDeclaration typedeclaration ) )
			int alt232 = 10;
			alt232 = this.dfa232.predict(this.input);
			switch (alt232) {
				case 1 :
				// ../rsc/CSharp.g3:2244:7: ( ( attributes )? ( constantmodifiers )? cONST )=> constantdeclaration
					{
						pushFollow(FOLLOW_constantdeclaration_in_structmemberdeclaration14347);
						constantdeclaration1004 = constantdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constantdeclaration
								.add(constantdeclaration1004.getTree());

						// AST REWRITE
						// elements: constantdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2245:5: -> ^( StructMemberDeclaration constantdeclaration )
							{
								// ../rsc/CSharp.g3:2245:8: ^( StructMemberDeclaration constantdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_constantdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2246:9: fielddeclaration
					{
						pushFollow(FOLLOW_fielddeclaration_in_structmemberdeclaration14369);
						fielddeclaration1005 = fielddeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_fielddeclaration.add(fielddeclaration1005
								.getTree());

						// AST REWRITE
						// elements: fielddeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2247:5: -> ^( StructMemberDeclaration fielddeclaration )
							{
								// ../rsc/CSharp.g3:2247:8: ^( StructMemberDeclaration fielddeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_fielddeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2248:9: ( methodheader )=> methoddeclaration
					{
						pushFollow(FOLLOW_methoddeclaration_in_structmemberdeclaration14397);
						methoddeclaration1006 = methoddeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_methoddeclaration.add(methoddeclaration1006
								.getTree());

						// AST REWRITE
						// elements: methoddeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2249:5: -> ^( StructMemberDeclaration methoddeclaration )
							{
								// ../rsc/CSharp.g3:2249:8: ^( StructMemberDeclaration methoddeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_methoddeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2250:9: propertydeclaration
					{
						pushFollow(FOLLOW_propertydeclaration_in_structmemberdeclaration14419);
						propertydeclaration1007 = propertydeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_propertydeclaration
								.add(propertydeclaration1007.getTree());

						// AST REWRITE
						// elements: propertydeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2251:5: -> ^( StructMemberDeclaration propertydeclaration )
							{
								// ../rsc/CSharp.g3:2251:8: ^( StructMemberDeclaration propertydeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_propertydeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2252:9: ( ( attributes )? ( eventmodifiers )? eVENT )=> eventdeclaration
					{
						pushFollow(FOLLOW_eventdeclaration_in_structmemberdeclaration14453);
						eventdeclaration1008 = eventdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_eventdeclaration.add(eventdeclaration1008
								.getTree());

						// AST REWRITE
						// elements: eventdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2253:5: -> ^( StructMemberDeclaration eventdeclaration )
							{
								// ../rsc/CSharp.g3:2253:8: ^( StructMemberDeclaration eventdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_eventdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:2254:9: ( ( attributes )? ( indexermodifiers )? indexerdeclarator )=> indexerdeclaration
					{
						pushFollow(FOLLOW_indexerdeclaration_in_structmemberdeclaration14487);
						indexerdeclaration1009 = indexerdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_indexerdeclaration
								.add(indexerdeclaration1009.getTree());

						// AST REWRITE
						// elements: indexerdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2255:5: -> ^( StructMemberDeclaration indexerdeclaration )
							{
								// ../rsc/CSharp.g3:2255:8: ^( StructMemberDeclaration indexerdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_indexerdeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 7 :
				// ../rsc/CSharp.g3:2256:9: ( ( attributes )? operatormodifiers operatordeclarator )=> operatordeclaration
					{
						pushFollow(FOLLOW_operatordeclaration_in_structmemberdeclaration14520);
						operatordeclaration1010 = operatordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_operatordeclaration
								.add(operatordeclaration1010.getTree());

						// AST REWRITE
						// elements: operatordeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2257:5: -> ^( StructMemberDeclaration operatordeclaration )
							{
								// ../rsc/CSharp.g3:2257:8: ^( StructMemberDeclaration operatordeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_operatordeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 8 :
				// ../rsc/CSharp.g3:2258:9: ( ( attributes )? ( constructormodifiers )? constructordeclarator )=> constructordeclaration
					{
						pushFollow(FOLLOW_constructordeclaration_in_structmemberdeclaration14554);
						constructordeclaration1011 = constructordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constructordeclaration
								.add(constructordeclaration1011.getTree());

						// AST REWRITE
						// elements: constructordeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2259:5: -> ^( StructMemberDeclaration constructordeclaration )
							{
								// ../rsc/CSharp.g3:2259:8: ^( StructMemberDeclaration constructordeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_constructordeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 9 :
				// ../rsc/CSharp.g3:2260:9: ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )=> staticconstructordeclaration
					{
						pushFollow(FOLLOW_staticconstructordeclaration_in_structmemberdeclaration14591);
						staticconstructordeclaration1012 =
							staticconstructordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_staticconstructordeclaration
								.add(staticconstructordeclaration1012.getTree());

						// AST REWRITE
						// elements: staticconstructordeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2261:5: -> ^( StructMemberDeclaration staticconstructordeclaration )
							{
								// ../rsc/CSharp.g3:2261:8: ^( StructMemberDeclaration staticconstructordeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_staticconstructordeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 10 :
				// ../rsc/CSharp.g3:2262:9: typedeclaration
					{
						pushFollow(FOLLOW_typedeclaration_in_structmemberdeclaration14613);
						typedeclaration1013 = typedeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_typedeclaration.add(typedeclaration1013
								.getTree());

						// AST REWRITE
						// elements: typedeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2263:5: -> ^( StructMemberDeclaration typedeclaration )
							{
								// ../rsc/CSharp.g3:2263:8: ^( StructMemberDeclaration typedeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												StructMemberDeclaration,
												"StructMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_typedeclaration.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "structmemberdeclaration"

	public static class arraytype_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "arraytype"
	// ../rsc/CSharp.g3:2267:1: arraytype returns [String signature] : nonarraytype rankspecifiers -> ^( ArrayType nonarraytype rankspecifiers ) ;
	public final CSharpParser.arraytype_return arraytype()
			throws RecognitionException {
		CSharpParser.arraytype_return retval =
			new CSharpParser.arraytype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nonarraytype_return nonarraytype1014 = null;

		CSharpParser.rankspecifiers_return rankspecifiers1015 = null;

		RewriteRuleSubtreeStream stream_rankspecifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rankspecifiers");
		RewriteRuleSubtreeStream stream_nonarraytype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nonarraytype");
		try {
			// ../rsc/CSharp.g3:2268:5: ( nonarraytype rankspecifiers -> ^( ArrayType nonarraytype rankspecifiers ) )
			// ../rsc/CSharp.g3:2268:9: nonarraytype rankspecifiers
			{
				pushFollow(FOLLOW_nonarraytype_in_arraytype14649);
				nonarraytype1014 = nonarraytype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_nonarraytype.add(nonarraytype1014.getTree());
				pushFollow(FOLLOW_rankspecifiers_in_arraytype14651);
				rankspecifiers1015 = rankspecifiers();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rankspecifiers.add(rankspecifiers1015.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(nonarraytype1014 != null ? nonarraytype1014.name
								: null)
								+ (rankspecifiers1015 != null ? rankspecifiers1015.signature
										: null);
				}

				// AST REWRITE
				// elements: rankspecifiers, nonarraytype
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2270:2: -> ^( ArrayType nonarraytype rankspecifiers )
					{
						// ../rsc/CSharp.g3:2270:5: ^( ArrayType nonarraytype rankspecifiers )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(ArrayType, "ArrayType"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_nonarraytype.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_rankspecifiers.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "arraytype"

	public static class nonarraytype_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "nonarraytype"
	// ../rsc/CSharp.g3:2273:1: nonarraytype returns [String name] : ( valuetype | classtype | interfacetype | delegatetype | typeparameter );
	public final CSharpParser.nonarraytype_return nonarraytype()
			throws RecognitionException {
		CSharpParser.nonarraytype_return retval =
			new CSharpParser.nonarraytype_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.valuetype_return valuetype1016 = null;

		CSharpParser.classtype_return classtype1017 = null;

		CSharpParser.interfacetype_return interfacetype1018 = null;

		CSharpParser.delegatetype_return delegatetype1019 = null;

		CSharpParser.typeparameter_return typeparameter1020 = null;

		try {
			// ../rsc/CSharp.g3:2274:5: ( valuetype | classtype | interfacetype | delegatetype | typeparameter )
			int alt233 = 5;
			alt233 = this.dfa233.predict(this.input);
			switch (alt233) {
				case 1 :
				// ../rsc/CSharp.g3:2274:9: valuetype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_valuetype_in_nonarraytype14692);
						valuetype1016 = valuetype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, valuetype1016.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(valuetype1016 != null ? valuetype1016.name
										: null);
						}

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2276:9: classtype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_classtype_in_nonarraytype14705);
						classtype1017 = classtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, classtype1017.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(classtype1017 != null ? classtype1017.name
										: null);
						}

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2278:9: interfacetype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_interfacetype_in_nonarraytype14718);
						interfacetype1018 = interfacetype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								interfacetype1018.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(interfacetype1018 != null ? interfacetype1018.name
										: null);
						}

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2280:9: delegatetype
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_delegatetype_in_nonarraytype14731);
						delegatetype1019 = delegatetype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor
								.addChild(root_0, delegatetype1019.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(delegatetype1019 != null ? delegatetype1019.name
										: null);
						}

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2282:9: typeparameter
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_typeparameter_in_nonarraytype14744);
						typeparameter1020 = typeparameter();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								typeparameter1020.getTree());
						if (this.state.backtracking == 0) {
							retval.name =
								(typeparameter1020 != null ? typeparameter1020.name
										: null);
						}

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "nonarraytype"

	public static class rankspecifiers_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rankspecifiers"
	// ../rsc/CSharp.g3:2286:1: rankspecifiers returns [String signature] : ( rankspecifier )+ -> ^( RankSpecifiers ( rankspecifier )+ ) ;
	public final CSharpParser.rankspecifiers_return rankspecifiers()
			throws RecognitionException {
		CSharpParser.rankspecifiers_return retval =
			new CSharpParser.rankspecifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.rankspecifier_return rankspecifier1021 = null;

		RewriteRuleSubtreeStream stream_rankspecifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rankspecifier");

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:2290:5: ( ( rankspecifier )+ -> ^( RankSpecifiers ( rankspecifier )+ ) )
			// ../rsc/CSharp.g3:2290:9: ( rankspecifier )+
			{
				// ../rsc/CSharp.g3:2290:9: ( rankspecifier )+
				int cnt234 = 0;
				loop234: do {
					int alt234 = 2;
					alt234 = this.dfa234.predict(this.input);
					switch (alt234) {
						case 1 :
						// ../rsc/CSharp.g3:2290:10: rankspecifier
							{
								pushFollow(FOLLOW_rankspecifier_in_rankspecifiers14777);
								rankspecifier1021 = rankspecifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_rankspecifier.add(rankspecifier1021
										.getTree());
								if (this.state.backtracking == 0) {
									sb
										.append((rankspecifier1021 != null ? rankspecifier1021.signature
												: null));
								}

							}
							break;

						default :
							if (cnt234 >= 1)
								break loop234;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(234, this.input);
							throw eee;
					}
					cnt234++;
				}
				while (true);

				if (this.state.backtracking == 0) {
					retval.signature = sb.toString();
				}

				// AST REWRITE
				// elements: rankspecifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2292:5: -> ^( RankSpecifiers ( rankspecifier )+ )
					{
						// ../rsc/CSharp.g3:2292:8: ^( RankSpecifiers ( rankspecifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										RankSpecifiers,
										"RankSpecifiers"),
									root_1);

							if (!(stream_rankspecifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_rankspecifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_rankspecifier.nextTree());

							}
							stream_rankspecifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rankspecifiers"

	public static class rankspecifier_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rankspecifier"
	// ../rsc/CSharp.g3:2295:1: rankspecifier returns [String signature] : lBRACKET ( dimseparators )? rBRACKET ;
	public final CSharpParser.rankspecifier_return rankspecifier()
			throws RecognitionException {
		CSharpParser.rankspecifier_return retval =
			new CSharpParser.rankspecifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACKET_return lBRACKET1022 = null;

		CSharpParser.dimseparators_return dimseparators1023 = null;

		CSharpParser.rBRACKET_return rBRACKET1024 = null;

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:2299:5: ( lBRACKET ( dimseparators )? rBRACKET )
			// ../rsc/CSharp.g3:2299:9: lBRACKET ( dimseparators )? rBRACKET
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_lBRACKET_in_rankspecifier14829);
				lBRACKET1022 = lBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, lBRACKET1022.getTree());
				// ../rsc/CSharp.g3:2299:18: ( dimseparators )?
				int alt235 = 2;
				int LA235_0 = this.input.LA(1);

				if ((LA235_0 == COMMA)) {
					alt235 = 1;
				}
				switch (alt235) {
					case 1 :
					// ../rsc/CSharp.g3:2299:19: dimseparators
						{
							pushFollow(FOLLOW_dimseparators_in_rankspecifier14832);
							dimseparators1023 = dimseparators();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								this.adaptor.addChild(
									root_0,
									dimseparators1023.getTree());
							if (this.state.backtracking == 0) {
								sb
									.append((dimseparators1023 != null ? dimseparators1023.signature
											: null));
							}

						}
						break;

				}

				pushFollow(FOLLOW_rBRACKET_in_rankspecifier14838);
				rBRACKET1024 = rBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, rBRACKET1024.getTree());
				if (this.state.backtracking == 0) {
					retval.signature = '[' + sb.toString() + ']';
				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rankspecifier"

	public static class dimseparators_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dimseparators"
	// ../rsc/CSharp.g3:2303:1: dimseparators returns [String signature] : ( cOMMA )+ ;
	public final CSharpParser.dimseparators_return dimseparators()
			throws RecognitionException {
		CSharpParser.dimseparators_return retval =
			new CSharpParser.dimseparators_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cOMMA_return cOMMA1025 = null;

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:2307:5: ( ( cOMMA )+ )
			// ../rsc/CSharp.g3:2307:9: ( cOMMA )+
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:2307:9: ( cOMMA )+
				int cnt236 = 0;
				loop236: do {
					int alt236 = 2;
					int LA236_0 = this.input.LA(1);

					if ((LA236_0 == COMMA)) {
						alt236 = 1;
					}

					switch (alt236) {
						case 1 :
						// ../rsc/CSharp.g3:2307:10: cOMMA
							{
								pushFollow(FOLLOW_cOMMA_in_dimseparators14875);
								cOMMA1025 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1025.getTree());
								if (this.state.backtracking == 0) {
									sb.append(',');
								}

							}
							break;

						default :
							if (cnt236 >= 1)
								break loop236;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(236, this.input);
							throw eee;
					}
					cnt236++;
				}
				while (true);

				if (this.state.backtracking == 0) {
					retval.signature = sb.toString();
				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dimseparators"

	public static class arrayinitializer_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "arrayinitializer"
	// ../rsc/CSharp.g3:2311:1: arrayinitializer : ( lBRACE ( variableinitializerlist )? rBRACE -> ^( ArrayInitializer lBRACE ( variableinitializerlist )? rBRACE ) | lBRACE variableinitializerlist cOMMA rBRACE -> ^( ArrayInitializer lBRACE variableinitializerlist cOMMA rBRACE ) );
	public final CSharpParser.arrayinitializer_return arrayinitializer()
			throws RecognitionException {
		CSharpParser.arrayinitializer_return retval =
			new CSharpParser.arrayinitializer_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACE_return lBRACE1026 = null;

		CSharpParser.variableinitializerlist_return variableinitializerlist1027 =
			null;

		CSharpParser.rBRACE_return rBRACE1028 = null;

		CSharpParser.lBRACE_return lBRACE1029 = null;

		CSharpParser.variableinitializerlist_return variableinitializerlist1030 =
			null;

		CSharpParser.cOMMA_return cOMMA1031 = null;

		CSharpParser.rBRACE_return rBRACE1032 = null;

		RewriteRuleSubtreeStream stream_variableinitializerlist =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule variableinitializerlist");
		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:2312:5: ( lBRACE ( variableinitializerlist )? rBRACE -> ^( ArrayInitializer lBRACE ( variableinitializerlist )? rBRACE ) | lBRACE variableinitializerlist cOMMA rBRACE -> ^( ArrayInitializer lBRACE variableinitializerlist cOMMA rBRACE ) )
			int alt238 = 2;
			int LA238_0 = this.input.LA(1);

			if ((LA238_0 == LBRACE)) {
				this.input.LA(2);

				if ((synpred567_CSharp())) {
					alt238 = 1;
				}
				else if ((true)) {
					alt238 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 238, 0, this.input);

				throw nvae;
			}
			switch (alt238) {
				case 1 :
				// ../rsc/CSharp.g3:2312:9: lBRACE ( variableinitializerlist )? rBRACE
					{
						pushFollow(FOLLOW_lBRACE_in_arrayinitializer14905);
						lBRACE1026 = lBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACE.add(lBRACE1026.getTree());
						// ../rsc/CSharp.g3:2312:16: ( variableinitializerlist )?
						int alt237 = 2;
						int LA237_0 = this.input.LA(1);

						if ((LA237_0 == LBRACE
								|| LA237_0 == LPAREN
								|| (LA237_0 >= PLUS && LA237_0 <= MINUS)
								|| (LA237_0 >= EXCLAM && LA237_0 <= TILDE)
								|| (LA237_0 >= INCREMENT && LA237_0 <= DECREMENT)
								|| (LA237_0 >= BASE && LA237_0 <= BOOL)
								|| LA237_0 == BYTE
								|| (LA237_0 >= CHAR && LA237_0 <= CHECKED)
								|| (LA237_0 >= DECIMAL && LA237_0 <= DELEGATE)
								|| LA237_0 == DOUBLE || LA237_0 == FALSE
								|| LA237_0 == FLOAT || LA237_0 == INT
								|| LA237_0 == LONG
								|| (LA237_0 >= NEW && LA237_0 <= OBJECT)
								|| LA237_0 == SBYTE || LA237_0 == SHORT
								|| LA237_0 == STRING || LA237_0 == THIS
								|| LA237_0 == TRUE
								|| (LA237_0 >= TYPEOF && LA237_0 <= UNCHECKED)
								|| LA237_0 == USHORT || (LA237_0 >= ADD && LA237_0 <= Stringliteral))) {
							alt237 = 1;
						}
						switch (alt237) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: variableinitializerlist
								{
									pushFollow(FOLLOW_variableinitializerlist_in_arrayinitializer14907);
									variableinitializerlist1027 =
										variableinitializerlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_variableinitializerlist
											.add(variableinitializerlist1027
												.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_rBRACE_in_arrayinitializer14910);
						rBRACE1028 = rBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACE.add(rBRACE1028.getTree());

						// AST REWRITE
						// elements: lBRACE, variableinitializerlist, rBRACE
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2313:5: -> ^( ArrayInitializer lBRACE ( variableinitializerlist )? rBRACE )
							{
								// ../rsc/CSharp.g3:2313:8: ^( ArrayInitializer lBRACE ( variableinitializerlist )? rBRACE )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ArrayInitializer,
												"ArrayInitializer"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lBRACE.nextTree());
									// ../rsc/CSharp.g3:2313:34: ( variableinitializerlist )?
									if (stream_variableinitializerlist
										.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_variableinitializerlist
												.nextTree());

									}
									stream_variableinitializerlist.reset();
									this.adaptor.addChild(
										root_1,
										stream_rBRACE.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2314:9: lBRACE variableinitializerlist cOMMA rBRACE
					{
						pushFollow(FOLLOW_lBRACE_in_arrayinitializer14937);
						lBRACE1029 = lBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACE.add(lBRACE1029.getTree());
						pushFollow(FOLLOW_variableinitializerlist_in_arrayinitializer14939);
						variableinitializerlist1030 = variableinitializerlist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_variableinitializerlist
								.add(variableinitializerlist1030.getTree());
						pushFollow(FOLLOW_cOMMA_in_arrayinitializer14941);
						cOMMA1031 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA1031.getTree());
						pushFollow(FOLLOW_rBRACE_in_arrayinitializer14943);
						rBRACE1032 = rBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACE.add(rBRACE1032.getTree());

						// AST REWRITE
						// elements: lBRACE, variableinitializerlist, rBRACE, cOMMA
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2315:5: -> ^( ArrayInitializer lBRACE variableinitializerlist cOMMA rBRACE )
							{
								// ../rsc/CSharp.g3:2315:8: ^( ArrayInitializer lBRACE variableinitializerlist cOMMA rBRACE )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												ArrayInitializer,
												"ArrayInitializer"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lBRACE.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_variableinitializerlist
											.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rBRACE.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "arrayinitializer"

	public static class variableinitializerlist_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "variableinitializerlist"
	// ../rsc/CSharp.g3:2319:1: variableinitializerlist : variableinitializer ( cOMMA variableinitializer )* ;
	public final CSharpParser.variableinitializerlist_return variableinitializerlist()
			throws RecognitionException {
		CSharpParser.variableinitializerlist_return retval =
			new CSharpParser.variableinitializerlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.variableinitializer_return variableinitializer1033 = null;

		CSharpParser.cOMMA_return cOMMA1034 = null;

		CSharpParser.variableinitializer_return variableinitializer1035 = null;

		try {
			// ../rsc/CSharp.g3:2320:5: ( variableinitializer ( cOMMA variableinitializer )* )
			// ../rsc/CSharp.g3:2320:9: variableinitializer ( cOMMA variableinitializer )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_variableinitializer_in_variableinitializerlist14982);
				variableinitializer1033 = variableinitializer();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, variableinitializer1033.getTree());
				// ../rsc/CSharp.g3:2320:29: ( cOMMA variableinitializer )*
				loop239: do {
					int alt239 = 2;
					alt239 = this.dfa239.predict(this.input);
					switch (alt239) {
						case 1 :
						// ../rsc/CSharp.g3:2320:30: cOMMA variableinitializer
							{
								pushFollow(FOLLOW_cOMMA_in_variableinitializerlist14985);
								cOMMA1034 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1034.getTree());
								pushFollow(FOLLOW_variableinitializer_in_variableinitializerlist14987);
								variableinitializer1035 = variableinitializer();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										variableinitializer1035.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "variableinitializerlist"

	public static class variableinitializer_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "variableinitializer"
	// ../rsc/CSharp.g3:2323:1: variableinitializer : ( expression | arrayinitializer );
	public final CSharpParser.variableinitializer_return variableinitializer()
			throws RecognitionException {
		CSharpParser.variableinitializer_return retval =
			new CSharpParser.variableinitializer_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.expression_return expression1036 = null;

		CSharpParser.arrayinitializer_return arrayinitializer1037 = null;

		try {
			// ../rsc/CSharp.g3:2324:5: ( expression | arrayinitializer )
			int alt240 = 2;
			int LA240_0 = this.input.LA(1);

			if ((LA240_0 == LPAREN || (LA240_0 >= PLUS && LA240_0 <= MINUS)
					|| (LA240_0 >= EXCLAM && LA240_0 <= TILDE)
					|| (LA240_0 >= INCREMENT && LA240_0 <= DECREMENT)
					|| (LA240_0 >= BASE && LA240_0 <= BOOL) || LA240_0 == BYTE
					|| (LA240_0 >= CHAR && LA240_0 <= CHECKED)
					|| (LA240_0 >= DECIMAL && LA240_0 <= DELEGATE)
					|| LA240_0 == DOUBLE || LA240_0 == FALSE
					|| LA240_0 == FLOAT || LA240_0 == INT || LA240_0 == LONG
					|| (LA240_0 >= NEW && LA240_0 <= OBJECT)
					|| LA240_0 == SBYTE || LA240_0 == SHORT
					|| LA240_0 == STRING || LA240_0 == THIS || LA240_0 == TRUE
					|| (LA240_0 >= TYPEOF && LA240_0 <= UNCHECKED)
					|| LA240_0 == USHORT || (LA240_0 >= ADD && LA240_0 <= Stringliteral))) {
				alt240 = 1;
			}
			else if ((LA240_0 == LBRACE)) {
				alt240 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 240, 0, this.input);

				throw nvae;
			}
			switch (alt240) {
				case 1 :
				// ../rsc/CSharp.g3:2324:9: expression
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_expression_in_variableinitializer15008);
						expression1036 = expression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, expression1036.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2325:9: arrayinitializer
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_arrayinitializer_in_variableinitializer15018);
						arrayinitializer1037 = arrayinitializer();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								arrayinitializer1037.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "variableinitializer"

	public static class interfacedeclaration_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacedeclaration"
	// ../rsc/CSharp.g3:2330:1: interfacedeclaration returns [String name] : ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE identifier ( typeparameterlist )? ( interfacebase )? ( typeparameterconstraintsclauses )? interfacebody ( sEMICOLON )? -> ^( Interface ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE identifier ( typeparameterlist )? ( interfacebase )? ( typeparameterconstraintsclauses )? interfacebody ( sEMICOLON )? ) ;
	public final CSharpParser.interfacedeclaration_return interfacedeclaration()
			throws RecognitionException {
		CSharpParser.interfacedeclaration_return retval =
			new CSharpParser.interfacedeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1038 = null;

		CSharpParser.interfacemodifiers_return interfacemodifiers1039 = null;

		CSharpParser.pARTIAL_return pARTIAL1040 = null;

		CSharpParser.iNTERFACE_return iNTERFACE1041 = null;

		CSharpParser.identifier_return identifier1042 = null;

		CSharpParser.typeparameterlist_return typeparameterlist1043 = null;

		CSharpParser.interfacebase_return interfacebase1044 = null;

		CSharpParser.typeparameterconstraintsclauses_return typeparameterconstraintsclauses1045 =
			null;

		CSharpParser.interfacebody_return interfacebody1046 = null;

		CSharpParser.sEMICOLON_return sEMICOLON1047 = null;

		RewriteRuleSubtreeStream stream_pARTIAL =
			new RewriteRuleSubtreeStream(this.adaptor, "rule pARTIAL");
		RewriteRuleSubtreeStream stream_iNTERFACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule iNTERFACE");
		RewriteRuleSubtreeStream stream_interfacemodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfacemodifiers");
		RewriteRuleSubtreeStream stream_typeparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameterlist");
		RewriteRuleSubtreeStream stream_typeparameterconstraintsclauses =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule typeparameterconstraintsclauses");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_interfacebody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfacebody");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_interfacebase =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfacebase");
		try {
			// ../rsc/CSharp.g3:2357:5: ( ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE identifier ( typeparameterlist )? ( interfacebase )? ( typeparameterconstraintsclauses )? interfacebody ( sEMICOLON )? -> ^( Interface ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE identifier ( typeparameterlist )? ( interfacebase )? ( typeparameterconstraintsclauses )? interfacebody ( sEMICOLON )? ) )
			// ../rsc/CSharp.g3:2357:9: ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE identifier ( typeparameterlist )? ( interfacebase )? ( typeparameterconstraintsclauses )? interfacebody ( sEMICOLON )?
			{
				// ../rsc/CSharp.g3:2357:9: ( attributes )?
				int alt241 = 2;
				int LA241_0 = this.input.LA(1);

				if ((LA241_0 == LBRACKET)) {
					alt241 = 1;
				}
				switch (alt241) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_interfacedeclaration15055);
							attributes1038 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes1038.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2357:21: ( interfacemodifiers )?
				int alt242 = 2;
				int LA242_0 = this.input.LA(1);

				if ((LA242_0 == INTERNAL || LA242_0 == NEW || (LA242_0 >= PRIVATE && LA242_0 <= PUBLIC))) {
					alt242 = 1;
				}
				switch (alt242) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: interfacemodifiers
						{
							pushFollow(FOLLOW_interfacemodifiers_in_interfacedeclaration15058);
							interfacemodifiers1039 = interfacemodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_interfacemodifiers
									.add(interfacemodifiers1039.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2357:41: ( pARTIAL )?
				int alt243 = 2;
				int LA243_0 = this.input.LA(1);

				if ((LA243_0 == PARTIAL)) {
					alt243 = 1;
				}
				switch (alt243) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: pARTIAL
						{
							pushFollow(FOLLOW_pARTIAL_in_interfacedeclaration15061);
							pARTIAL1040 = pARTIAL();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_pARTIAL.add(pARTIAL1040.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_iNTERFACE_in_interfacedeclaration15064);
				iNTERFACE1041 = iNTERFACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_iNTERFACE.add(iNTERFACE1041.getTree());
				pushFollow(FOLLOW_identifier_in_interfacedeclaration15066);
				identifier1042 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1042.getTree());
				// ../rsc/CSharp.g3:2357:71: ( typeparameterlist )?
				int alt244 = 2;
				int LA244_0 = this.input.LA(1);

				if ((LA244_0 == LT)) {
					alt244 = 1;
				}
				switch (alt244) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterlist
						{
							pushFollow(FOLLOW_typeparameterlist_in_interfacedeclaration15068);
							typeparameterlist1043 = typeparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterlist
									.add(typeparameterlist1043.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2358:7: ( interfacebase )?
				int alt245 = 2;
				int LA245_0 = this.input.LA(1);

				if ((LA245_0 == COLON)) {
					alt245 = 1;
				}
				switch (alt245) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: interfacebase
						{
							pushFollow(FOLLOW_interfacebase_in_interfacedeclaration15077);
							interfacebase1044 = interfacebase();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_interfacebase.add(interfacebase1044
									.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2358:22: ( typeparameterconstraintsclauses )?
				int alt246 = 2;
				int LA246_0 = this.input.LA(1);

				if ((LA246_0 == WHERE)) {
					alt246 = 1;
				}
				switch (alt246) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterconstraintsclauses
						{
							pushFollow(FOLLOW_typeparameterconstraintsclauses_in_interfacedeclaration15080);
							typeparameterconstraintsclauses1045 =
								typeparameterconstraintsclauses();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterconstraintsclauses
									.add(typeparameterconstraintsclauses1045
										.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_interfacebody_in_interfacedeclaration15083);
				interfacebody1046 = interfacebody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_interfacebody.add(interfacebody1046.getTree());
				// ../rsc/CSharp.g3:2358:69: ( sEMICOLON )?
				int alt247 = 2;
				int LA247_0 = this.input.LA(1);

				if ((LA247_0 == SEMICOLON)) {
					alt247 = 1;
				}
				switch (alt247) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: sEMICOLON
						{
							pushFollow(FOLLOW_sEMICOLON_in_interfacedeclaration15085);
							sEMICOLON1047 = sEMICOLON();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_sEMICOLON.add(sEMICOLON1047.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {
					retval.name =
						(identifier1042 != null ? identifier1042.content : null);
				}

				// AST REWRITE
				// elements: interfacemodifiers, attributes, identifier, typeparameterlist, iNTERFACE, pARTIAL, interfacebody, typeparameterconstraintsclauses, interfacebase, sEMICOLON
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2360:5: -> ^( Interface ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE identifier ( typeparameterlist )? ( interfacebase )? ( typeparameterconstraintsclauses )? interfacebody ( sEMICOLON )? )
					{
						// ../rsc/CSharp.g3:2360:8: ^( Interface ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE identifier ( typeparameterlist )? ( interfacebase )? ( typeparameterconstraintsclauses )? interfacebody ( sEMICOLON )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Interface, "Interface"), root_1);

							// ../rsc/CSharp.g3:2360:20: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2360:32: ( interfacemodifiers )?
							if (stream_interfacemodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_interfacemodifiers.nextTree());

							}
							stream_interfacemodifiers.reset();
							// ../rsc/CSharp.g3:2360:52: ( pARTIAL )?
							if (stream_pARTIAL.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_pARTIAL.nextTree());

							}
							stream_pARTIAL.reset();
							this.adaptor.addChild(
								root_1,
								stream_iNTERFACE.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:2360:82: ( typeparameterlist )?
							if (stream_typeparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterlist.nextTree());

							}
							stream_typeparameterlist.reset();
							// ../rsc/CSharp.g3:2361:7: ( interfacebase )?
							if (stream_interfacebase.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_interfacebase.nextTree());

							}
							stream_interfacebase.reset();
							// ../rsc/CSharp.g3:2361:22: ( typeparameterconstraintsclauses )?
							if (stream_typeparameterconstraintsclauses
								.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterconstraintsclauses
										.nextTree());

							}
							stream_typeparameterconstraintsclauses.reset();
							this.adaptor.addChild(
								root_1,
								stream_interfacebody.nextTree());
							// ../rsc/CSharp.g3:2361:69: ( sEMICOLON )?
							if (stream_sEMICOLON.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_sEMICOLON.nextTree());

							}
							stream_sEMICOLON.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

				//System.out.println(((Object) retval.tree));
				//System.out.println(retval.name);

					final IInterface element2 =
						this.getFactory().createInterface(
							retval.name.toCharArray(),
							retval.name.toCharArray());

					codeLevelModel.addConstituent(element2);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacedeclaration"

	public static class interfacemodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacemodifiers"
	// ../rsc/CSharp.g3:2364:1: interfacemodifiers : ( interfacemodifier )+ -> ^( Modifiers ( interfacemodifier )+ ) ;
	public final CSharpParser.interfacemodifiers_return interfacemodifiers()
			throws RecognitionException {
		CSharpParser.interfacemodifiers_return retval =
			new CSharpParser.interfacemodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.interfacemodifier_return interfacemodifier1048 = null;

		RewriteRuleSubtreeStream stream_interfacemodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfacemodifier");
		try {
			// ../rsc/CSharp.g3:2365:5: ( ( interfacemodifier )+ -> ^( Modifiers ( interfacemodifier )+ ) )
			// ../rsc/CSharp.g3:2365:9: ( interfacemodifier )+
			{
				// ../rsc/CSharp.g3:2365:9: ( interfacemodifier )+
				int cnt248 = 0;
				loop248: do {
					int alt248 = 2;
					int LA248_0 = this.input.LA(1);

					if ((LA248_0 == INTERNAL || LA248_0 == NEW || (LA248_0 >= PRIVATE && LA248_0 <= PUBLIC))) {
						alt248 = 1;
					}

					switch (alt248) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: interfacemodifier
							{
								pushFollow(FOLLOW_interfacemodifier_in_interfacemodifiers15156);
								interfacemodifier1048 = interfacemodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_interfacemodifier
										.add(interfacemodifier1048.getTree());

							}
							break;

						default :
							if (cnt248 >= 1)
								break loop248;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(248, this.input);
							throw eee;
					}
					cnt248++;
				}
				while (true);

				// AST REWRITE
				// elements: interfacemodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2366:5: -> ^( Modifiers ( interfacemodifier )+ )
					{
						// ../rsc/CSharp.g3:2366:8: ^( Modifiers ( interfacemodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_interfacemodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_interfacemodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_interfacemodifier.nextTree());

							}
							stream_interfacemodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacemodifiers"

	public static class interfacemodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacemodifier"
	// ../rsc/CSharp.g3:2369:1: interfacemodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE );
	public final CSharpParser.interfacemodifier_return interfacemodifier()
			throws RecognitionException {
		CSharpParser.interfacemodifier_return retval =
			new CSharpParser.interfacemodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW1049 = null;

		CSharpParser.pUBLIC_return pUBLIC1050 = null;

		CSharpParser.pROTECTED_return pROTECTED1051 = null;

		CSharpParser.iNTERNAL_return iNTERNAL1052 = null;

		CSharpParser.pRIVATE_return pRIVATE1053 = null;

		try {
			// ../rsc/CSharp.g3:2370:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE )
			int alt249 = 5;
			switch (this.input.LA(1)) {
				case NEW :
					{
						alt249 = 1;
					}
					break;
				case PUBLIC :
					{
						alt249 = 2;
					}
					break;
				case PROTECTED :
					{
						alt249 = 3;
					}
					break;
				case INTERNAL :
					{
						alt249 = 4;
					}
					break;
				case PRIVATE :
					{
						alt249 = 5;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 249, 0, this.input);

					throw nvae;
			}

			switch (alt249) {
				case 1 :
				// ../rsc/CSharp.g3:2370:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_interfacemodifier15189);
						nEW1049 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW1049.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2371:10: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_interfacemodifier15200);
						pUBLIC1050 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC1050.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2372:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_interfacemodifier15210);
						pROTECTED1051 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED1051.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2373:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_interfacemodifier15220);
						iNTERNAL1052 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL1052.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2374:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_interfacemodifier15230);
						pRIVATE1053 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE1053.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacemodifier"

	public static class interfacebase_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacebase"
	// ../rsc/CSharp.g3:2377:1: interfacebase : cOLON interfacetypelist ;
	public final CSharpParser.interfacebase_return interfacebase()
			throws RecognitionException {
		CSharpParser.interfacebase_return retval =
			new CSharpParser.interfacebase_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cOLON_return cOLON1054 = null;

		CSharpParser.interfacetypelist_return interfacetypelist1055 = null;

		try {
			// ../rsc/CSharp.g3:2378:5: ( cOLON interfacetypelist )
			// ../rsc/CSharp.g3:2378:9: cOLON interfacetypelist
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_cOLON_in_interfacebase15249);
				cOLON1054 = cOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, cOLON1054.getTree());
				pushFollow(FOLLOW_interfacetypelist_in_interfacebase15251);
				interfacetypelist1055 = interfacetypelist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, interfacetypelist1055.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacebase"

	public static class interfacebody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacebody"
	// ../rsc/CSharp.g3:2381:1: interfacebody : lBRACE ( interfacememberdeclaration )* rBRACE -> ^( Body lBRACE ( interfacememberdeclaration )* rBRACE ) ;
	public final CSharpParser.interfacebody_return interfacebody()
			throws RecognitionException {
		CSharpParser.interfacebody_return retval =
			new CSharpParser.interfacebody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACE_return lBRACE1056 = null;

		CSharpParser.interfacememberdeclaration_return interfacememberdeclaration1057 =
			null;

		CSharpParser.rBRACE_return rBRACE1058 = null;

		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_interfacememberdeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule interfacememberdeclaration");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:2382:5: ( lBRACE ( interfacememberdeclaration )* rBRACE -> ^( Body lBRACE ( interfacememberdeclaration )* rBRACE ) )
			// ../rsc/CSharp.g3:2382:9: lBRACE ( interfacememberdeclaration )* rBRACE
			{
				pushFollow(FOLLOW_lBRACE_in_interfacebody15270);
				lBRACE1056 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE1056.getTree());
				// ../rsc/CSharp.g3:2382:16: ( interfacememberdeclaration )*
				loop250: do {
					int alt250 = 2;
					int LA250_0 = this.input.LA(1);

					if ((LA250_0 == LBRACKET || LA250_0 == BOOL
							|| LA250_0 == BYTE || LA250_0 == CHAR
							|| LA250_0 == DECIMAL || LA250_0 == DOUBLE
							|| LA250_0 == EVENT || LA250_0 == FLOAT
							|| LA250_0 == INT || LA250_0 == LONG
							|| LA250_0 == NEW || LA250_0 == OBJECT
							|| LA250_0 == SBYTE || LA250_0 == SHORT
							|| LA250_0 == STRING
							|| (LA250_0 >= UINT && LA250_0 <= ULONG)
							|| LA250_0 == USHORT || LA250_0 == VOID || (LA250_0 >= ADD && LA250_0 <= Ident))) {
						alt250 = 1;
					}

					switch (alt250) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: interfacememberdeclaration
							{
								pushFollow(FOLLOW_interfacememberdeclaration_in_interfacebody15272);
								interfacememberdeclaration1057 =
									interfacememberdeclaration();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_interfacememberdeclaration
										.add(interfacememberdeclaration1057
											.getTree());

							}
							break;

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

				pushFollow(FOLLOW_rBRACE_in_interfacebody15275);
				rBRACE1058 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE1058.getTree());

				// AST REWRITE
				// elements: rBRACE, lBRACE, interfacememberdeclaration
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2383:5: -> ^( Body lBRACE ( interfacememberdeclaration )* rBRACE )
					{
						// ../rsc/CSharp.g3:2383:8: ^( Body lBRACE ( interfacememberdeclaration )* rBRACE )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Body, "Body"),
									root_1);

							this.adaptor.addChild(root_1, stream_lBRACE.nextTree());
							// ../rsc/CSharp.g3:2383:22: ( interfacememberdeclaration )*
							while (stream_interfacememberdeclaration.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_interfacememberdeclaration
										.nextTree());

							}
							stream_interfacememberdeclaration.reset();
							this.adaptor.addChild(root_1, stream_rBRACE.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacebody"

	public static class interfacememberdeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacememberdeclaration"
	// ../rsc/CSharp.g3:2387:1: interfacememberdeclaration : ( interfacemethoddeclaration -> ^( InterfaceMemberDeclaration interfacemethoddeclaration ) | interfacepropertydeclaration -> ^( InterfaceMemberDeclaration interfacepropertydeclaration ) | interfaceeventdeclaration -> ^( InterfaceMemberDeclaration interfaceeventdeclaration ) | interfaceindexerdeclaration -> ^( InterfaceMemberDeclaration interfaceindexerdeclaration ) );
	public final CSharpParser.interfacememberdeclaration_return interfacememberdeclaration()
			throws RecognitionException {
		CSharpParser.interfacememberdeclaration_return retval =
			new CSharpParser.interfacememberdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.interfacemethoddeclaration_return interfacemethoddeclaration1059 =
			null;

		CSharpParser.interfacepropertydeclaration_return interfacepropertydeclaration1060 =
			null;

		CSharpParser.interfaceeventdeclaration_return interfaceeventdeclaration1061 =
			null;

		CSharpParser.interfaceindexerdeclaration_return interfaceindexerdeclaration1062 =
			null;

		RewriteRuleSubtreeStream stream_interfaceeventdeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule interfaceeventdeclaration");
		RewriteRuleSubtreeStream stream_interfaceindexerdeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule interfaceindexerdeclaration");
		RewriteRuleSubtreeStream stream_interfacemethoddeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule interfacemethoddeclaration");
		RewriteRuleSubtreeStream stream_interfacepropertydeclaration =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule interfacepropertydeclaration");
		try {
			// ../rsc/CSharp.g3:2388:5: ( interfacemethoddeclaration -> ^( InterfaceMemberDeclaration interfacemethoddeclaration ) | interfacepropertydeclaration -> ^( InterfaceMemberDeclaration interfacepropertydeclaration ) | interfaceeventdeclaration -> ^( InterfaceMemberDeclaration interfaceeventdeclaration ) | interfaceindexerdeclaration -> ^( InterfaceMemberDeclaration interfaceindexerdeclaration ) )
			int alt251 = 4;
			alt251 = this.dfa251.predict(this.input);
			switch (alt251) {
				case 1 :
				// ../rsc/CSharp.g3:2388:9: interfacemethoddeclaration
					{
						pushFollow(FOLLOW_interfacemethoddeclaration_in_interfacememberdeclaration15312);
						interfacemethoddeclaration1059 =
							interfacemethoddeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_interfacemethoddeclaration
								.add(interfacemethoddeclaration1059.getTree());

						// AST REWRITE
						// elements: interfacemethoddeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2389:5: -> ^( InterfaceMemberDeclaration interfacemethoddeclaration )
							{
								// ../rsc/CSharp.g3:2389:8: ^( InterfaceMemberDeclaration interfacemethoddeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												InterfaceMemberDeclaration,
												"InterfaceMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_interfacemethoddeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2390:9: interfacepropertydeclaration
					{
						pushFollow(FOLLOW_interfacepropertydeclaration_in_interfacememberdeclaration15334);
						interfacepropertydeclaration1060 =
							interfacepropertydeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_interfacepropertydeclaration
								.add(interfacepropertydeclaration1060.getTree());

						// AST REWRITE
						// elements: interfacepropertydeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2391:5: -> ^( InterfaceMemberDeclaration interfacepropertydeclaration )
							{
								// ../rsc/CSharp.g3:2391:8: ^( InterfaceMemberDeclaration interfacepropertydeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												InterfaceMemberDeclaration,
												"InterfaceMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_interfacepropertydeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2392:9: interfaceeventdeclaration
					{
						pushFollow(FOLLOW_interfaceeventdeclaration_in_interfacememberdeclaration15356);
						interfaceeventdeclaration1061 =
							interfaceeventdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_interfaceeventdeclaration
								.add(interfaceeventdeclaration1061.getTree());

						// AST REWRITE
						// elements: interfaceeventdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2393:5: -> ^( InterfaceMemberDeclaration interfaceeventdeclaration )
							{
								// ../rsc/CSharp.g3:2393:8: ^( InterfaceMemberDeclaration interfaceeventdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												InterfaceMemberDeclaration,
												"InterfaceMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_interfaceeventdeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2394:9: interfaceindexerdeclaration
					{
						pushFollow(FOLLOW_interfaceindexerdeclaration_in_interfacememberdeclaration15378);
						interfaceindexerdeclaration1062 =
							interfaceindexerdeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_interfaceindexerdeclaration
								.add(interfaceindexerdeclaration1062.getTree());

						// AST REWRITE
						// elements: interfaceindexerdeclaration
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2395:5: -> ^( InterfaceMemberDeclaration interfaceindexerdeclaration )
							{
								// ../rsc/CSharp.g3:2395:8: ^( InterfaceMemberDeclaration interfaceindexerdeclaration )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												InterfaceMemberDeclaration,
												"InterfaceMemberDeclaration"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_interfaceindexerdeclaration
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacememberdeclaration"

	public static class interfacemethoddeclaration_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacemethoddeclaration"
	// ../rsc/CSharp.g3:2398:1: interfacemethoddeclaration returns [String signature] : ( attributes )? ( nEW )? returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON -> ^( InterfaceMethod ( attributes )? ( ^( Modifiers nEW ) )? returntype identifier ( typeparameterlist )? ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( typeparameterconstraintsclauses )? sEMICOLON ) ;
	public final CSharpParser.interfacemethoddeclaration_return interfacemethoddeclaration()
			throws RecognitionException {
		CSharpParser.interfacemethoddeclaration_return retval =
			new CSharpParser.interfacemethoddeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1063 = null;

		CSharpParser.nEW_return nEW1064 = null;

		CSharpParser.returntype_return returntype1065 = null;

		CSharpParser.identifier_return identifier1066 = null;

		CSharpParser.typeparameterlist_return typeparameterlist1067 = null;

		CSharpParser.lPAREN_return lPAREN1068 = null;

		CSharpParser.formalparameterlist_return formalparameterlist1069 = null;

		CSharpParser.rPAREN_return rPAREN1070 = null;

		CSharpParser.typeparameterconstraintsclauses_return typeparameterconstraintsclauses1071 =
			null;

		CSharpParser.sEMICOLON_return sEMICOLON1072 = null;

		RewriteRuleSubtreeStream stream_typeparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameterlist");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_typeparameterconstraintsclauses =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule typeparameterconstraintsclauses");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_nEW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nEW");
		RewriteRuleSubtreeStream stream_formalparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule formalparameterlist");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_returntype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule returntype");

		String formalParams = "";
		String typeParams = "";

		try {
			// ../rsc/CSharp.g3:2406:5: ( ( attributes )? ( nEW )? returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON -> ^( InterfaceMethod ( attributes )? ( ^( Modifiers nEW ) )? returntype identifier ( typeparameterlist )? ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( typeparameterconstraintsclauses )? sEMICOLON ) )
			// ../rsc/CSharp.g3:2406:9: ( attributes )? ( nEW )? returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON
			{
				// ../rsc/CSharp.g3:2406:9: ( attributes )?
				int alt252 = 2;
				int LA252_0 = this.input.LA(1);

				if ((LA252_0 == LBRACKET)) {
					alt252 = 1;
				}
				switch (alt252) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_interfacemethoddeclaration15423);
							attributes1063 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes1063.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2406:21: ( nEW )?
				int alt253 = 2;
				int LA253_0 = this.input.LA(1);

				if ((LA253_0 == NEW)) {
					alt253 = 1;
				}
				switch (alt253) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: nEW
						{
							pushFollow(FOLLOW_nEW_in_interfacemethoddeclaration15426);
							nEW1064 = nEW();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_nEW.add(nEW1064.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_returntype_in_interfacemethoddeclaration15429);
				returntype1065 = returntype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_returntype.add(returntype1065.getTree());
				pushFollow(FOLLOW_identifier_in_interfacemethoddeclaration15431);
				identifier1066 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1066.getTree());
				// ../rsc/CSharp.g3:2407:6: ( typeparameterlist )?
				int alt254 = 2;
				int LA254_0 = this.input.LA(1);

				if ((LA254_0 == LT)) {
					alt254 = 1;
				}
				switch (alt254) {
					case 1 :
					// ../rsc/CSharp.g3:2407:7: typeparameterlist
						{
							pushFollow(FOLLOW_typeparameterlist_in_interfacemethoddeclaration15439);
							typeparameterlist1067 = typeparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterlist
									.add(typeparameterlist1067.getTree());
							if (this.state.backtracking == 0) {
								typeParams =
									(typeparameterlist1067 != null ? typeparameterlist1067.signature
											: null);
							}

						}
						break;

				}

				pushFollow(FOLLOW_lPAREN_in_interfacemethoddeclaration15450);
				lPAREN1068 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN1068.getTree());
				// ../rsc/CSharp.g3:2409:6: ( formalparameterlist )?
				int alt255 = 2;
				int LA255_0 = this.input.LA(1);

				if ((LA255_0 == LBRACKET || LA255_0 == BOOL || LA255_0 == BYTE
						|| LA255_0 == CHAR || LA255_0 == DECIMAL
						|| LA255_0 == DOUBLE || LA255_0 == FLOAT
						|| LA255_0 == INT || LA255_0 == LONG
						|| LA255_0 == OBJECT || LA255_0 == OUT
						|| LA255_0 == PARAMS || LA255_0 == REF
						|| LA255_0 == SBYTE || LA255_0 == SHORT
						|| LA255_0 == STRING
						|| (LA255_0 >= UINT && LA255_0 <= ULONG)
						|| LA255_0 == USHORT || (LA255_0 >= ADD && LA255_0 <= Ident))) {
					alt255 = 1;
				}
				switch (alt255) {
					case 1 :
					// ../rsc/CSharp.g3:2409:7: formalparameterlist
						{
							pushFollow(FOLLOW_formalparameterlist_in_interfacemethoddeclaration15458);
							formalparameterlist1069 = formalparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_formalparameterlist
									.add(formalparameterlist1069.getTree());
							if (this.state.backtracking == 0) {
								formalParams =
									(formalparameterlist1069 != null ? formalparameterlist1069.signature
											: null);
							}

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_interfacemethoddeclaration15469);
				rPAREN1070 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN1070.getTree());
				// ../rsc/CSharp.g3:2410:13: ( typeparameterconstraintsclauses )?
				int alt256 = 2;
				int LA256_0 = this.input.LA(1);

				if ((LA256_0 == WHERE)) {
					alt256 = 1;
				}
				switch (alt256) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterconstraintsclauses
						{
							pushFollow(FOLLOW_typeparameterconstraintsclauses_in_interfacemethoddeclaration15471);
							typeparameterconstraintsclauses1071 =
								typeparameterconstraintsclauses();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterconstraintsclauses
									.add(typeparameterconstraintsclauses1071
										.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_sEMICOLON_in_interfacemethoddeclaration15474);
				sEMICOLON1072 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON1072.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(identifier1066 != null ? identifier1066.content : null)
								+ typeParams + '(' + formalParams + ')';
				}

				// AST REWRITE
				// elements: returntype, lPAREN, attributes, formalparameterlist, typeparameterlist, typeparameterconstraintsclauses, sEMICOLON, identifier, nEW, rPAREN
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2412:2: -> ^( InterfaceMethod ( attributes )? ( ^( Modifiers nEW ) )? returntype identifier ( typeparameterlist )? ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( typeparameterconstraintsclauses )? sEMICOLON )
					{
						// ../rsc/CSharp.g3:2412:5: ^( InterfaceMethod ( attributes )? ( ^( Modifiers nEW ) )? returntype identifier ( typeparameterlist )? ^( ParameterList lPAREN ( formalparameterlist )? rPAREN ) ( typeparameterconstraintsclauses )? sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										InterfaceMethod,
										"InterfaceMethod"),
									root_1);

							// ../rsc/CSharp.g3:2412:23: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2412:35: ( ^( Modifiers nEW ) )?
							if (stream_nEW.hasNext()) {
								// ../rsc/CSharp.g3:2412:35: ^( Modifiers nEW )
								{
									Object root_2 = (Object) this.adaptor.nil();
									root_2 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_2);

									this.adaptor.addChild(
										root_2,
										stream_nEW.nextTree());

									this.adaptor.addChild(root_1, root_2);
								}

							}
							stream_nEW.reset();
							this.adaptor.addChild(
								root_1,
								stream_returntype.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:2412:75: ( typeparameterlist )?
							if (stream_typeparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterlist.nextTree());

							}
							stream_typeparameterlist.reset();
							// ../rsc/CSharp.g3:2413:7: ^( ParameterList lPAREN ( formalparameterlist )? rPAREN )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											ParameterList,
											"ParameterList"),
										root_2);

								this.adaptor.addChild(
									root_2,
									stream_lPAREN.nextTree());
								// ../rsc/CSharp.g3:2413:30: ( formalparameterlist )?
								if (stream_formalparameterlist.hasNext()) {
									this.adaptor.addChild(
										root_2,
										stream_formalparameterlist.nextTree());

								}
								stream_formalparameterlist.reset();
								this.adaptor.addChild(
									root_2,
									stream_rPAREN.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}
							// ../rsc/CSharp.g3:2413:59: ( typeparameterconstraintsclauses )?
							if (stream_typeparameterconstraintsclauses
								.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterconstraintsclauses
										.nextTree());

							}
							stream_typeparameterconstraintsclauses.reset();
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.signature);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacemethoddeclaration"

	public static class interfacepropertydeclaration_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfacepropertydeclaration"
	// ../rsc/CSharp.g3:2416:1: interfacepropertydeclaration returns [String name] : ( attributes )? ( nEW )? type identifier lBRACE interfaceaccessors rBRACE -> ^( InterfaceProperty ( attributes )? ( ^( Modifiers nEW ) )? type identifier ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE ) ) ;
	public final CSharpParser.interfacepropertydeclaration_return interfacepropertydeclaration()
			throws RecognitionException {
		CSharpParser.interfacepropertydeclaration_return retval =
			new CSharpParser.interfacepropertydeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1073 = null;

		CSharpParser.nEW_return nEW1074 = null;

		CSharpParser.type_return type1075 = null;

		CSharpParser.identifier_return identifier1076 = null;

		CSharpParser.lBRACE_return lBRACE1077 = null;

		CSharpParser.interfaceaccessors_return interfaceaccessors1078 = null;

		CSharpParser.rBRACE_return rBRACE1079 = null;

		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_interfaceaccessors =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfaceaccessors");
		RewriteRuleSubtreeStream stream_nEW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nEW");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:2420:5: ( ( attributes )? ( nEW )? type identifier lBRACE interfaceaccessors rBRACE -> ^( InterfaceProperty ( attributes )? ( ^( Modifiers nEW ) )? type identifier ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE ) ) )
			// ../rsc/CSharp.g3:2420:9: ( attributes )? ( nEW )? type identifier lBRACE interfaceaccessors rBRACE
			{
				// ../rsc/CSharp.g3:2420:9: ( attributes )?
				int alt257 = 2;
				int LA257_0 = this.input.LA(1);

				if ((LA257_0 == LBRACKET)) {
					alt257 = 1;
				}
				switch (alt257) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_interfacepropertydeclaration15555);
							attributes1073 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes1073.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2420:21: ( nEW )?
				int alt258 = 2;
				int LA258_0 = this.input.LA(1);

				if ((LA258_0 == NEW)) {
					alt258 = 1;
				}
				switch (alt258) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: nEW
						{
							pushFollow(FOLLOW_nEW_in_interfacepropertydeclaration15558);
							nEW1074 = nEW();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_nEW.add(nEW1074.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_type_in_interfacepropertydeclaration15561);
				type1075 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type1075.getTree());
				pushFollow(FOLLOW_identifier_in_interfacepropertydeclaration15563);
				identifier1076 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1076.getTree());
				pushFollow(FOLLOW_lBRACE_in_interfacepropertydeclaration15565);
				lBRACE1077 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE1077.getTree());
				pushFollow(FOLLOW_interfaceaccessors_in_interfacepropertydeclaration15567);
				interfaceaccessors1078 = interfaceaccessors();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_interfaceaccessors.add(interfaceaccessors1078
						.getTree());
				pushFollow(FOLLOW_rBRACE_in_interfacepropertydeclaration15569);
				rBRACE1079 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE1079.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(identifier1076 != null ? identifier1076.content : null);
				}

				// AST REWRITE
				// elements: attributes, lBRACE, type, identifier, rBRACE, interfaceaccessors, nEW
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2422:5: -> ^( InterfaceProperty ( attributes )? ( ^( Modifiers nEW ) )? type identifier ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE ) )
					{
						// ../rsc/CSharp.g3:2422:8: ^( InterfaceProperty ( attributes )? ( ^( Modifiers nEW ) )? type identifier ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE ) )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										InterfaceProperty,
										"InterfaceProperty"), root_1);

							// ../rsc/CSharp.g3:2422:28: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2422:40: ( ^( Modifiers nEW ) )?
							if (stream_nEW.hasNext()) {
								// ../rsc/CSharp.g3:2422:40: ^( Modifiers nEW )
								{
									Object root_2 = (Object) this.adaptor.nil();
									root_2 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_2);

									this.adaptor.addChild(
										root_2,
										stream_nEW.nextTree());

									this.adaptor.addChild(root_1, root_2);
								}

							}
							stream_nEW.reset();
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:2423:6: ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											AccessorDeclarations,
											"AccessorDeclarations"),
										root_2);

								this.adaptor.addChild(
									root_2,
									stream_lBRACE.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_interfaceaccessors.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_rBRACE.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfacepropertydeclaration"

	public static class interfaceaccessors_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfaceaccessors"
	// ../rsc/CSharp.g3:2426:1: interfaceaccessors : ( ( attributes )? gET sEMICOLON ( ( attributes )? sET sEMICOLON )? -> ^( GetAccessor ( attributes )? gET sEMICOLON ) ( ^( SetAccessor ( attributes )? sET sEMICOLON ) )? | ( attributes )? sET sEMICOLON ( ( attributes )? gET sEMICOLON )? -> ^( SetAccessor ( attributes )? sET sEMICOLON ) ( ^( GetAccessor ( attributes )? gET sEMICOLON ) )? );
	public final CSharpParser.interfaceaccessors_return interfaceaccessors()
			throws RecognitionException {
		CSharpParser.interfaceaccessors_return retval =
			new CSharpParser.interfaceaccessors_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1080 = null;

		CSharpParser.gET_return gET1081 = null;

		CSharpParser.sEMICOLON_return sEMICOLON1082 = null;

		CSharpParser.attributes_return attributes1083 = null;

		CSharpParser.sET_return sET1084 = null;

		CSharpParser.sEMICOLON_return sEMICOLON1085 = null;

		CSharpParser.attributes_return attributes1086 = null;

		CSharpParser.sET_return sET1087 = null;

		CSharpParser.sEMICOLON_return sEMICOLON1088 = null;

		CSharpParser.attributes_return attributes1089 = null;

		CSharpParser.gET_return gET1090 = null;

		CSharpParser.sEMICOLON_return sEMICOLON1091 = null;

		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_gET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gET");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_sET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sET");
		try {
			// ../rsc/CSharp.g3:2427:5: ( ( attributes )? gET sEMICOLON ( ( attributes )? sET sEMICOLON )? -> ^( GetAccessor ( attributes )? gET sEMICOLON ) ( ^( SetAccessor ( attributes )? sET sEMICOLON ) )? | ( attributes )? sET sEMICOLON ( ( attributes )? gET sEMICOLON )? -> ^( SetAccessor ( attributes )? sET sEMICOLON ) ( ^( GetAccessor ( attributes )? gET sEMICOLON ) )? )
			int alt265 = 2;
			switch (this.input.LA(1)) {
				case LBRACKET :
					{
						this.input.LA(2);

						if ((synpred596_CSharp())) {
							alt265 = 1;
						}
						else if ((true)) {
							alt265 = 2;
						}
					}
					break;
				case GET :
					{
						alt265 = 1;
					}
					break;
				case SET :
					{
						alt265 = 2;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 265, 0, this.input);

					throw nvae;
			}

			switch (alt265) {
				case 1 :
				// ../rsc/CSharp.g3:2427:9: ( attributes )? gET sEMICOLON ( ( attributes )? sET sEMICOLON )?
					{
						// ../rsc/CSharp.g3:2427:9: ( attributes )?
						int alt259 = 2;
						int LA259_0 = this.input.LA(1);

						if ((LA259_0 == LBRACKET)) {
							alt259 = 1;
						}
						switch (alt259) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: attributes
								{
									pushFollow(FOLLOW_attributes_in_interfaceaccessors15634);
									attributes1080 = attributes();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_attributes.add(attributes1080
											.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_gET_in_interfaceaccessors15637);
						gET1081 = gET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_gET.add(gET1081.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_interfaceaccessors15639);
						sEMICOLON1082 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON1082.getTree());
						// ../rsc/CSharp.g3:2427:35: ( ( attributes )? sET sEMICOLON )?
						int alt261 = 2;
						int LA261_0 = this.input.LA(1);

						if ((LA261_0 == LBRACKET || LA261_0 == SET)) {
							alt261 = 1;
						}
						switch (alt261) {
							case 1 :
							// ../rsc/CSharp.g3:2427:36: ( attributes )? sET sEMICOLON
								{
									// ../rsc/CSharp.g3:2427:36: ( attributes )?
									int alt260 = 2;
									int LA260_0 = this.input.LA(1);

									if ((LA260_0 == LBRACKET)) {
										alt260 = 1;
									}
									switch (alt260) {
										case 1 :
										// ../rsc/CSharp.g3:0:0: attributes
											{
												pushFollow(FOLLOW_attributes_in_interfaceaccessors15642);
												attributes1083 = attributes();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_attributes
														.add(attributes1083
															.getTree());

											}
											break;

									}

									pushFollow(FOLLOW_sET_in_interfaceaccessors15645);
									sET1084 = sET();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_sET.add(sET1084.getTree());
									pushFollow(FOLLOW_sEMICOLON_in_interfaceaccessors15647);
									sEMICOLON1085 = sEMICOLON();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_sEMICOLON.add(sEMICOLON1085
											.getTree());

								}
								break;

						}

						// AST REWRITE
						// elements: sEMICOLON, attributes, sEMICOLON, sET, gET, attributes
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2428:5: -> ^( GetAccessor ( attributes )? gET sEMICOLON ) ( ^( SetAccessor ( attributes )? sET sEMICOLON ) )?
							{
								// ../rsc/CSharp.g3:2428:8: ^( GetAccessor ( attributes )? gET sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												GetAccessor,
												"GetAccessor"),
											root_1);

									// ../rsc/CSharp.g3:2428:22: ( attributes )?
									if (stream_attributes.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_attributes.nextTree());

									}
									stream_attributes.reset();
									this.adaptor.addChild(
										root_1,
										stream_gET.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}
								// ../rsc/CSharp.g3:2428:49: ( ^( SetAccessor ( attributes )? sET sEMICOLON ) )?
								if (stream_attributes.hasNext()
										|| stream_sEMICOLON.hasNext()
										|| stream_sET.hasNext()) {
									// ../rsc/CSharp.g3:2428:50: ^( SetAccessor ( attributes )? sET sEMICOLON )
									{
										Object root_1 = (Object) this.adaptor.nil();
										root_1 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													SetAccessor,
													"SetAccessor"),
												root_1);

										// ../rsc/CSharp.g3:2428:64: ( attributes )?
										if (stream_attributes.hasNext()) {
											this.adaptor.addChild(
												root_1,
												stream_attributes.nextTree());

										}
										stream_attributes.reset();
										this.adaptor.addChild(
											root_1,
											stream_sET.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_sEMICOLON.nextTree());

										this.adaptor.addChild(root_0, root_1);
									}

								}
								stream_attributes.reset();
								stream_sEMICOLON.reset();
								stream_sET.reset();

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2429:9: ( attributes )? sET sEMICOLON ( ( attributes )? gET sEMICOLON )?
					{
						// ../rsc/CSharp.g3:2429:9: ( attributes )?
						int alt262 = 2;
						int LA262_0 = this.input.LA(1);

						if ((LA262_0 == LBRACKET)) {
							alt262 = 1;
						}
						switch (alt262) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: attributes
								{
									pushFollow(FOLLOW_attributes_in_interfaceaccessors15690);
									attributes1086 = attributes();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_attributes.add(attributes1086
											.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_sET_in_interfaceaccessors15693);
						sET1087 = sET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sET.add(sET1087.getTree());
						pushFollow(FOLLOW_sEMICOLON_in_interfaceaccessors15695);
						sEMICOLON1088 = sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sEMICOLON.add(sEMICOLON1088.getTree());
						// ../rsc/CSharp.g3:2429:35: ( ( attributes )? gET sEMICOLON )?
						int alt264 = 2;
						int LA264_0 = this.input.LA(1);

						if ((LA264_0 == LBRACKET || LA264_0 == GET)) {
							alt264 = 1;
						}
						switch (alt264) {
							case 1 :
							// ../rsc/CSharp.g3:2429:36: ( attributes )? gET sEMICOLON
								{
									// ../rsc/CSharp.g3:2429:36: ( attributes )?
									int alt263 = 2;
									int LA263_0 = this.input.LA(1);

									if ((LA263_0 == LBRACKET)) {
										alt263 = 1;
									}
									switch (alt263) {
										case 1 :
										// ../rsc/CSharp.g3:0:0: attributes
											{
												pushFollow(FOLLOW_attributes_in_interfaceaccessors15698);
												attributes1089 = attributes();

												this.state._fsp--;
												if (this.state.failed)
													return retval;
												if (this.state.backtracking == 0)
													stream_attributes
														.add(attributes1089
															.getTree());

											}
											break;

									}

									pushFollow(FOLLOW_gET_in_interfaceaccessors15701);
									gET1090 = gET();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_gET.add(gET1090.getTree());
									pushFollow(FOLLOW_sEMICOLON_in_interfaceaccessors15703);
									sEMICOLON1091 = sEMICOLON();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_sEMICOLON.add(sEMICOLON1091
											.getTree());

								}
								break;

						}

						// AST REWRITE
						// elements: sEMICOLON, sET, attributes, sEMICOLON, attributes, gET
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2430:5: -> ^( SetAccessor ( attributes )? sET sEMICOLON ) ( ^( GetAccessor ( attributes )? gET sEMICOLON ) )?
							{
								// ../rsc/CSharp.g3:2430:9: ^( SetAccessor ( attributes )? sET sEMICOLON )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												SetAccessor,
												"SetAccessor"),
											root_1);

									// ../rsc/CSharp.g3:2430:23: ( attributes )?
									if (stream_attributes.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_attributes.nextTree());

									}
									stream_attributes.reset();
									this.adaptor.addChild(
										root_1,
										stream_sET.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_sEMICOLON.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}
								// ../rsc/CSharp.g3:2430:50: ( ^( GetAccessor ( attributes )? gET sEMICOLON ) )?
								if (stream_sEMICOLON.hasNext()
										|| stream_attributes.hasNext()
										|| stream_gET.hasNext()) {
									// ../rsc/CSharp.g3:2430:51: ^( GetAccessor ( attributes )? gET sEMICOLON )
									{
										Object root_1 = (Object) this.adaptor.nil();
										root_1 =
											(Object) this.adaptor.becomeRoot(
												(Object) this.adaptor.create(
													GetAccessor,
													"GetAccessor"),
												root_1);

										// ../rsc/CSharp.g3:2430:65: ( attributes )?
										if (stream_attributes.hasNext()) {
											this.adaptor.addChild(
												root_1,
												stream_attributes.nextTree());

										}
										stream_attributes.reset();
										this.adaptor.addChild(
											root_1,
											stream_gET.nextTree());
										this.adaptor.addChild(
											root_1,
											stream_sEMICOLON.nextTree());

										this.adaptor.addChild(root_0, root_1);
									}

								}
								stream_sEMICOLON.reset();
								stream_attributes.reset();
								stream_gET.reset();

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfaceaccessors"

	public static class interfaceeventdeclaration_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfaceeventdeclaration"
	// ../rsc/CSharp.g3:2433:1: interfaceeventdeclaration returns [String name] : ( attributes )? ( nEW )? eVENT type identifier sEMICOLON -> ^( InterfaceEvent ( attributes )? ( ^( Modifiers nEW ) )? eVENT type identifier sEMICOLON ) ;
	public final CSharpParser.interfaceeventdeclaration_return interfaceeventdeclaration()
			throws RecognitionException {
		CSharpParser.interfaceeventdeclaration_return retval =
			new CSharpParser.interfaceeventdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1092 = null;

		CSharpParser.nEW_return nEW1093 = null;

		CSharpParser.eVENT_return eVENT1094 = null;

		CSharpParser.type_return type1095 = null;

		CSharpParser.identifier_return identifier1096 = null;

		CSharpParser.sEMICOLON_return sEMICOLON1097 = null;

		RewriteRuleSubtreeStream stream_nEW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nEW");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_eVENT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eVENT");
		try {
			// ../rsc/CSharp.g3:2437:5: ( ( attributes )? ( nEW )? eVENT type identifier sEMICOLON -> ^( InterfaceEvent ( attributes )? ( ^( Modifiers nEW ) )? eVENT type identifier sEMICOLON ) )
			// ../rsc/CSharp.g3:2437:9: ( attributes )? ( nEW )? eVENT type identifier sEMICOLON
			{
				// ../rsc/CSharp.g3:2437:9: ( attributes )?
				int alt266 = 2;
				int LA266_0 = this.input.LA(1);

				if ((LA266_0 == LBRACKET)) {
					alt266 = 1;
				}
				switch (alt266) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_interfaceeventdeclaration15765);
							attributes1092 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes1092.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2437:21: ( nEW )?
				int alt267 = 2;
				int LA267_0 = this.input.LA(1);

				if ((LA267_0 == NEW)) {
					alt267 = 1;
				}
				switch (alt267) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: nEW
						{
							pushFollow(FOLLOW_nEW_in_interfaceeventdeclaration15768);
							nEW1093 = nEW();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_nEW.add(nEW1093.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_eVENT_in_interfaceeventdeclaration15771);
				eVENT1094 = eVENT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_eVENT.add(eVENT1094.getTree());
				pushFollow(FOLLOW_type_in_interfaceeventdeclaration15773);
				type1095 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type1095.getTree());
				pushFollow(FOLLOW_identifier_in_interfaceeventdeclaration15775);
				identifier1096 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1096.getTree());
				pushFollow(FOLLOW_sEMICOLON_in_interfaceeventdeclaration15777);
				sEMICOLON1097 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON1097.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(identifier1096 != null ? identifier1096.content : null);
				}

				// AST REWRITE
				// elements: attributes, type, sEMICOLON, nEW, identifier, eVENT
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2439:5: -> ^( InterfaceEvent ( attributes )? ( ^( Modifiers nEW ) )? eVENT type identifier sEMICOLON )
					{
						// ../rsc/CSharp.g3:2439:8: ^( InterfaceEvent ( attributes )? ( ^( Modifiers nEW ) )? eVENT type identifier sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										InterfaceEvent,
										"InterfaceEvent"),
									root_1);

							// ../rsc/CSharp.g3:2439:25: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2439:37: ( ^( Modifiers nEW ) )?
							if (stream_nEW.hasNext()) {
								// ../rsc/CSharp.g3:2439:37: ^( Modifiers nEW )
								{
									Object root_2 = (Object) this.adaptor.nil();
									root_2 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_2);

									this.adaptor.addChild(
										root_2,
										stream_nEW.nextTree());

									this.adaptor.addChild(root_1, root_2);
								}

							}
							stream_nEW.reset();
							this.adaptor.addChild(root_1, stream_eVENT.nextTree());
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfaceeventdeclaration"

	public static class interfaceindexerdeclaration_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "interfaceindexerdeclaration"
	// ../rsc/CSharp.g3:2442:1: interfaceindexerdeclaration returns [String signature] : ( attributes )? ( nEW )? type tHIS lBRACKET formalparameterlist rBRACKET lBRACE interfaceaccessors rBRACE -> ^( InterfaceIndexer ( attributes )? ( ^( Modifiers nEW ) )? type tHIS ^( ParameterList lBRACKET formalparameterlist rBRACKET ) ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE ) ) ;
	public final CSharpParser.interfaceindexerdeclaration_return interfaceindexerdeclaration()
			throws RecognitionException {
		CSharpParser.interfaceindexerdeclaration_return retval =
			new CSharpParser.interfaceindexerdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1098 = null;

		CSharpParser.nEW_return nEW1099 = null;

		CSharpParser.type_return type1100 = null;

		CSharpParser.tHIS_return tHIS1101 = null;

		CSharpParser.lBRACKET_return lBRACKET1102 = null;

		CSharpParser.formalparameterlist_return formalparameterlist1103 = null;

		CSharpParser.rBRACKET_return rBRACKET1104 = null;

		CSharpParser.lBRACE_return lBRACE1105 = null;

		CSharpParser.interfaceaccessors_return interfaceaccessors1106 = null;

		CSharpParser.rBRACE_return rBRACE1107 = null;

		RewriteRuleSubtreeStream stream_tHIS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule tHIS");
		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_lBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACKET");
		RewriteRuleSubtreeStream stream_interfaceaccessors =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfaceaccessors");
		RewriteRuleSubtreeStream stream_nEW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nEW");
		RewriteRuleSubtreeStream stream_formalparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule formalparameterlist");
		RewriteRuleSubtreeStream stream_rBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACKET");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_type =
			new RewriteRuleSubtreeStream(this.adaptor, "rule type");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:2446:5: ( ( attributes )? ( nEW )? type tHIS lBRACKET formalparameterlist rBRACKET lBRACE interfaceaccessors rBRACE -> ^( InterfaceIndexer ( attributes )? ( ^( Modifiers nEW ) )? type tHIS ^( ParameterList lBRACKET formalparameterlist rBRACKET ) ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE ) ) )
			// ../rsc/CSharp.g3:2446:9: ( attributes )? ( nEW )? type tHIS lBRACKET formalparameterlist rBRACKET lBRACE interfaceaccessors rBRACE
			{
				// ../rsc/CSharp.g3:2446:9: ( attributes )?
				int alt268 = 2;
				int LA268_0 = this.input.LA(1);

				if ((LA268_0 == LBRACKET)) {
					alt268 = 1;
				}
				switch (alt268) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_interfaceindexerdeclaration15840);
							attributes1098 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes1098.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2446:21: ( nEW )?
				int alt269 = 2;
				int LA269_0 = this.input.LA(1);

				if ((LA269_0 == NEW)) {
					alt269 = 1;
				}
				switch (alt269) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: nEW
						{
							pushFollow(FOLLOW_nEW_in_interfaceindexerdeclaration15843);
							nEW1099 = nEW();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_nEW.add(nEW1099.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_type_in_interfaceindexerdeclaration15846);
				type1100 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_type.add(type1100.getTree());
				pushFollow(FOLLOW_tHIS_in_interfaceindexerdeclaration15848);
				tHIS1101 = tHIS();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_tHIS.add(tHIS1101.getTree());
				pushFollow(FOLLOW_lBRACKET_in_interfaceindexerdeclaration15850);
				lBRACKET1102 = lBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACKET.add(lBRACKET1102.getTree());
				pushFollow(FOLLOW_formalparameterlist_in_interfaceindexerdeclaration15852);
				formalparameterlist1103 = formalparameterlist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_formalparameterlist.add(formalparameterlist1103
						.getTree());
				pushFollow(FOLLOW_rBRACKET_in_interfaceindexerdeclaration15854);
				rBRACKET1104 = rBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACKET.add(rBRACKET1104.getTree());
				pushFollow(FOLLOW_lBRACE_in_interfaceindexerdeclaration15856);
				lBRACE1105 = lBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACE.add(lBRACE1105.getTree());
				pushFollow(FOLLOW_interfaceaccessors_in_interfaceindexerdeclaration15858);
				interfaceaccessors1106 = interfaceaccessors();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_interfaceaccessors.add(interfaceaccessors1106
						.getTree());
				pushFollow(FOLLOW_rBRACE_in_interfaceindexerdeclaration15860);
				rBRACE1107 = rBRACE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACE.add(rBRACE1107.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						"this"
								+ '['
								+ (formalparameterlist1103 != null ? formalparameterlist1103.signature
										: null) + ']';
				}

				// AST REWRITE
				// elements: tHIS, rBRACE, rBRACKET, lBRACE, interfaceaccessors, lBRACKET, formalparameterlist, attributes, nEW, type
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2448:5: -> ^( InterfaceIndexer ( attributes )? ( ^( Modifiers nEW ) )? type tHIS ^( ParameterList lBRACKET formalparameterlist rBRACKET ) ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE ) )
					{
						// ../rsc/CSharp.g3:2448:8: ^( InterfaceIndexer ( attributes )? ( ^( Modifiers nEW ) )? type tHIS ^( ParameterList lBRACKET formalparameterlist rBRACKET ) ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE ) )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										InterfaceIndexer,
										"InterfaceIndexer"), root_1);

							// ../rsc/CSharp.g3:2448:27: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2448:39: ( ^( Modifiers nEW ) )?
							if (stream_nEW.hasNext()) {
								// ../rsc/CSharp.g3:2448:39: ^( Modifiers nEW )
								{
									Object root_2 = (Object) this.adaptor.nil();
									root_2 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Modifiers,
												"Modifiers"),
											root_2);

									this.adaptor.addChild(
										root_2,
										stream_nEW.nextTree());

									this.adaptor.addChild(root_1, root_2);
								}

							}
							stream_nEW.reset();
							this.adaptor.addChild(root_1, stream_type.nextTree());
							this.adaptor.addChild(root_1, stream_tHIS.nextTree());
							// ../rsc/CSharp.g3:2449:6: ^( ParameterList lBRACKET formalparameterlist rBRACKET )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											ParameterList,
											"ParameterList"),
										root_2);

								this.adaptor.addChild(
									root_2,
									stream_lBRACKET.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_formalparameterlist.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_rBRACKET.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}
							// ../rsc/CSharp.g3:2450:6: ^( AccessorDeclarations lBRACE interfaceaccessors rBRACE )
							{
								Object root_2 = (Object) this.adaptor.nil();
								root_2 =
									(Object) this.adaptor.becomeRoot(
										(Object) this.adaptor.create(
											AccessorDeclarations,
											"AccessorDeclarations"),
										root_2);

								this.adaptor.addChild(
									root_2,
									stream_lBRACE.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_interfaceaccessors.nextTree());
								this.adaptor.addChild(
									root_2,
									stream_rBRACE.nextTree());

								this.adaptor.addChild(root_1, root_2);
							}

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.signature);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "interfaceindexerdeclaration"

	public static class enumdeclaration_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "enumdeclaration"
	// ../rsc/CSharp.g3:2455:1: enumdeclaration returns [String name] : ( attributes )? ( enummodifiers )? eNUM identifier ( enumbase )? enumbody ( sEMICOLON )? -> ^( Enum ( attributes )? ( enummodifiers )? eNUM identifier ( enumbase )? enumbody ( sEMICOLON )? ) ;
	public final CSharpParser.enumdeclaration_return enumdeclaration()
			throws RecognitionException {
		CSharpParser.enumdeclaration_return retval =
			new CSharpParser.enumdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1108 = null;

		CSharpParser.enummodifiers_return enummodifiers1109 = null;

		CSharpParser.eNUM_return eNUM1110 = null;

		CSharpParser.identifier_return identifier1111 = null;

		CSharpParser.enumbase_return enumbase1112 = null;

		CSharpParser.enumbody_return enumbody1113 = null;

		CSharpParser.sEMICOLON_return sEMICOLON1114 = null;

		RewriteRuleSubtreeStream stream_enumbase =
			new RewriteRuleSubtreeStream(this.adaptor, "rule enumbase");
		RewriteRuleSubtreeStream stream_eNUM =
			new RewriteRuleSubtreeStream(this.adaptor, "rule eNUM");
		RewriteRuleSubtreeStream stream_enummodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule enummodifiers");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_enumbody =
			new RewriteRuleSubtreeStream(this.adaptor, "rule enumbody");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		try {
			// ../rsc/CSharp.g3:2459:5: ( ( attributes )? ( enummodifiers )? eNUM identifier ( enumbase )? enumbody ( sEMICOLON )? -> ^( Enum ( attributes )? ( enummodifiers )? eNUM identifier ( enumbase )? enumbody ( sEMICOLON )? ) )
			// ../rsc/CSharp.g3:2459:9: ( attributes )? ( enummodifiers )? eNUM identifier ( enumbase )? enumbody ( sEMICOLON )?
			{
				// ../rsc/CSharp.g3:2459:9: ( attributes )?
				int alt270 = 2;
				int LA270_0 = this.input.LA(1);

				if ((LA270_0 == LBRACKET)) {
					alt270 = 1;
				}
				switch (alt270) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_enumdeclaration15951);
							attributes1108 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes1108.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2459:21: ( enummodifiers )?
				int alt271 = 2;
				int LA271_0 = this.input.LA(1);

				if ((LA271_0 == INTERNAL || LA271_0 == NEW || (LA271_0 >= PRIVATE && LA271_0 <= PUBLIC))) {
					alt271 = 1;
				}
				switch (alt271) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: enummodifiers
						{
							pushFollow(FOLLOW_enummodifiers_in_enumdeclaration15954);
							enummodifiers1109 = enummodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_enummodifiers.add(enummodifiers1109
									.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_eNUM_in_enumdeclaration15957);
				eNUM1110 = eNUM();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_eNUM.add(eNUM1110.getTree());
				pushFollow(FOLLOW_identifier_in_enumdeclaration15959);
				identifier1111 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1111.getTree());
				// ../rsc/CSharp.g3:2459:52: ( enumbase )?
				int alt272 = 2;
				int LA272_0 = this.input.LA(1);

				if ((LA272_0 == COLON)) {
					alt272 = 1;
				}
				switch (alt272) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: enumbase
						{
							pushFollow(FOLLOW_enumbase_in_enumdeclaration15961);
							enumbase1112 = enumbase();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_enumbase.add(enumbase1112.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_enumbody_in_enumdeclaration15964);
				enumbody1113 = enumbody();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_enumbody.add(enumbody1113.getTree());
				// ../rsc/CSharp.g3:2459:71: ( sEMICOLON )?
				int alt273 = 2;
				int LA273_0 = this.input.LA(1);

				if ((LA273_0 == SEMICOLON)) {
					alt273 = 1;
				}
				switch (alt273) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: sEMICOLON
						{
							pushFollow(FOLLOW_sEMICOLON_in_enumdeclaration15966);
							sEMICOLON1114 = sEMICOLON();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_sEMICOLON.add(sEMICOLON1114.getTree());

						}
						break;

				}

				if (this.state.backtracking == 0) {
					retval.name =
						(identifier1111 != null ? identifier1111.content : null);
				}

				// AST REWRITE
				// elements: enumbase, enummodifiers, identifier, eNUM, sEMICOLON, attributes, enumbody
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2461:5: -> ^( Enum ( attributes )? ( enummodifiers )? eNUM identifier ( enumbase )? enumbody ( sEMICOLON )? )
					{
						// ../rsc/CSharp.g3:2461:9: ^( Enum ( attributes )? ( enummodifiers )? eNUM identifier ( enumbase )? enumbody ( sEMICOLON )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(Enum, "Enum"),
									root_1);

							// ../rsc/CSharp.g3:2461:16: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2461:28: ( enummodifiers )?
							if (stream_enummodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_enummodifiers.nextTree());

							}
							stream_enummodifiers.reset();
							this.adaptor.addChild(root_1, stream_eNUM.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:2461:59: ( enumbase )?
							if (stream_enumbase.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_enumbase.nextTree());

							}
							stream_enumbase.reset();
							this.adaptor
								.addChild(root_1, stream_enumbody.nextTree());
							// ../rsc/CSharp.g3:2461:78: ( sEMICOLON )?
							if (stream_sEMICOLON.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_sEMICOLON.nextTree());

							}
							stream_sEMICOLON.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "enumdeclaration"

	public static class enumbase_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "enumbase"
	// ../rsc/CSharp.g3:2464:1: enumbase : cOLON integralType ;
	public final CSharpParser.enumbase_return enumbase()
			throws RecognitionException {
		CSharpParser.enumbase_return retval =
			new CSharpParser.enumbase_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cOLON_return cOLON1115 = null;

		CSharpParser.integralType_return integralType1116 = null;

		try {
			// ../rsc/CSharp.g3:2465:5: ( cOLON integralType )
			// ../rsc/CSharp.g3:2465:9: cOLON integralType
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_cOLON_in_enumbase16022);
				cOLON1115 = cOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, cOLON1115.getTree());
				pushFollow(FOLLOW_integralType_in_enumbase16024);
				integralType1116 = integralType();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, integralType1116.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "enumbase"

	public static class enumbody_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "enumbody"
	// ../rsc/CSharp.g3:2468:1: enumbody : ( lBRACE ( enummemberdeclarations )? rBRACE -> ^( Body lBRACE ( enummemberdeclarations )? rBRACE ) | lBRACE enummemberdeclarations cOMMA rBRACE -> ^( Body lBRACE enummemberdeclarations cOMMA rBRACE ) );
	public final CSharpParser.enumbody_return enumbody()
			throws RecognitionException {
		CSharpParser.enumbody_return retval =
			new CSharpParser.enumbody_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACE_return lBRACE1117 = null;

		CSharpParser.enummemberdeclarations_return enummemberdeclarations1118 =
			null;

		CSharpParser.rBRACE_return rBRACE1119 = null;

		CSharpParser.lBRACE_return lBRACE1120 = null;

		CSharpParser.enummemberdeclarations_return enummemberdeclarations1121 =
			null;

		CSharpParser.cOMMA_return cOMMA1122 = null;

		CSharpParser.rBRACE_return rBRACE1123 = null;

		RewriteRuleSubtreeStream stream_rBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACE");
		RewriteRuleSubtreeStream stream_enummemberdeclarations =
			new RewriteRuleSubtreeStream(this.adaptor, "rule enummemberdeclarations");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		RewriteRuleSubtreeStream stream_lBRACE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACE");
		try {
			// ../rsc/CSharp.g3:2469:5: ( lBRACE ( enummemberdeclarations )? rBRACE -> ^( Body lBRACE ( enummemberdeclarations )? rBRACE ) | lBRACE enummemberdeclarations cOMMA rBRACE -> ^( Body lBRACE enummemberdeclarations cOMMA rBRACE ) )
			int alt275 = 2;
			int LA275_0 = this.input.LA(1);

			if ((LA275_0 == LBRACE)) {
				this.input.LA(2);

				if ((synpred609_CSharp())) {
					alt275 = 1;
				}
				else if ((true)) {
					alt275 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 275, 0, this.input);

				throw nvae;
			}
			switch (alt275) {
				case 1 :
				// ../rsc/CSharp.g3:2469:9: lBRACE ( enummemberdeclarations )? rBRACE
					{
						pushFollow(FOLLOW_lBRACE_in_enumbody16043);
						lBRACE1117 = lBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACE.add(lBRACE1117.getTree());
						// ../rsc/CSharp.g3:2469:16: ( enummemberdeclarations )?
						int alt274 = 2;
						int LA274_0 = this.input.LA(1);

						if ((LA274_0 == LBRACKET || (LA274_0 >= ADD && LA274_0 <= Ident))) {
							alt274 = 1;
						}
						switch (alt274) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: enummemberdeclarations
								{
									pushFollow(FOLLOW_enummemberdeclarations_in_enumbody16045);
									enummemberdeclarations1118 =
										enummemberdeclarations();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_enummemberdeclarations
											.add(enummemberdeclarations1118
												.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_rBRACE_in_enumbody16048);
						rBRACE1119 = rBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACE.add(rBRACE1119.getTree());

						// AST REWRITE
						// elements: rBRACE, lBRACE, enummemberdeclarations
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2470:5: -> ^( Body lBRACE ( enummemberdeclarations )? rBRACE )
							{
								// ../rsc/CSharp.g3:2470:8: ^( Body lBRACE ( enummemberdeclarations )? rBRACE )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Body,
												"Body"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lBRACE.nextTree());
									// ../rsc/CSharp.g3:2470:22: ( enummemberdeclarations )?
									if (stream_enummemberdeclarations.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_enummemberdeclarations
												.nextTree());

									}
									stream_enummemberdeclarations.reset();
									this.adaptor.addChild(
										root_1,
										stream_rBRACE.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2471:9: lBRACE enummemberdeclarations cOMMA rBRACE
					{
						pushFollow(FOLLOW_lBRACE_in_enumbody16075);
						lBRACE1120 = lBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACE.add(lBRACE1120.getTree());
						pushFollow(FOLLOW_enummemberdeclarations_in_enumbody16077);
						enummemberdeclarations1121 = enummemberdeclarations();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_enummemberdeclarations
								.add(enummemberdeclarations1121.getTree());
						pushFollow(FOLLOW_cOMMA_in_enumbody16079);
						cOMMA1122 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA1122.getTree());
						pushFollow(FOLLOW_rBRACE_in_enumbody16081);
						rBRACE1123 = rBRACE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACE.add(rBRACE1123.getTree());

						// AST REWRITE
						// elements: enummemberdeclarations, cOMMA, lBRACE, rBRACE
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2472:5: -> ^( Body lBRACE enummemberdeclarations cOMMA rBRACE )
							{
								// ../rsc/CSharp.g3:2472:9: ^( Body lBRACE enummemberdeclarations cOMMA rBRACE )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												Body,
												"Body"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lBRACE.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_enummemberdeclarations
											.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rBRACE.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "enumbody"

	public static class enummodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "enummodifiers"
	// ../rsc/CSharp.g3:2475:1: enummodifiers : ( enummodifier )+ -> ^( Modifiers ( enummodifier )+ ) ;
	public final CSharpParser.enummodifiers_return enummodifiers()
			throws RecognitionException {
		CSharpParser.enummodifiers_return retval =
			new CSharpParser.enummodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.enummodifier_return enummodifier1124 = null;

		RewriteRuleSubtreeStream stream_enummodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule enummodifier");
		try {
			// ../rsc/CSharp.g3:2476:5: ( ( enummodifier )+ -> ^( Modifiers ( enummodifier )+ ) )
			// ../rsc/CSharp.g3:2476:9: ( enummodifier )+
			{
				// ../rsc/CSharp.g3:2476:9: ( enummodifier )+
				int cnt276 = 0;
				loop276: do {
					int alt276 = 2;
					int LA276_0 = this.input.LA(1);

					if ((LA276_0 == INTERNAL || LA276_0 == NEW || (LA276_0 >= PRIVATE && LA276_0 <= PUBLIC))) {
						alt276 = 1;
					}

					switch (alt276) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: enummodifier
							{
								pushFollow(FOLLOW_enummodifier_in_enummodifiers16120);
								enummodifier1124 = enummodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_enummodifier.add(enummodifier1124
										.getTree());

							}
							break;

						default :
							if (cnt276 >= 1)
								break loop276;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(276, this.input);
							throw eee;
					}
					cnt276++;
				}
				while (true);

				// AST REWRITE
				// elements: enummodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2477:5: -> ^( Modifiers ( enummodifier )+ )
					{
						// ../rsc/CSharp.g3:2477:8: ^( Modifiers ( enummodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_enummodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_enummodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_enummodifier.nextTree());

							}
							stream_enummodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "enummodifiers"

	public static class enummodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "enummodifier"
	// ../rsc/CSharp.g3:2480:1: enummodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE );
	public final CSharpParser.enummodifier_return enummodifier()
			throws RecognitionException {
		CSharpParser.enummodifier_return retval =
			new CSharpParser.enummodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW1125 = null;

		CSharpParser.pUBLIC_return pUBLIC1126 = null;

		CSharpParser.pROTECTED_return pROTECTED1127 = null;

		CSharpParser.iNTERNAL_return iNTERNAL1128 = null;

		CSharpParser.pRIVATE_return pRIVATE1129 = null;

		try {
			// ../rsc/CSharp.g3:2481:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE )
			int alt277 = 5;
			switch (this.input.LA(1)) {
				case NEW :
					{
						alt277 = 1;
					}
					break;
				case PUBLIC :
					{
						alt277 = 2;
					}
					break;
				case PROTECTED :
					{
						alt277 = 3;
					}
					break;
				case INTERNAL :
					{
						alt277 = 4;
					}
					break;
				case PRIVATE :
					{
						alt277 = 5;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 277, 0, this.input);

					throw nvae;
			}

			switch (alt277) {
				case 1 :
				// ../rsc/CSharp.g3:2481:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_enummodifier16153);
						nEW1125 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW1125.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2482:10: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_enummodifier16164);
						pUBLIC1126 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC1126.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2483:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_enummodifier16174);
						pROTECTED1127 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED1127.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2484:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_enummodifier16184);
						iNTERNAL1128 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL1128.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2485:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_enummodifier16194);
						pRIVATE1129 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE1129.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "enummodifier"

	public static class enummemberdeclarations_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "enummemberdeclarations"
	// ../rsc/CSharp.g3:2488:1: enummemberdeclarations : enummemberdeclaration ( cOMMA enummemberdeclaration )* ;
	public final CSharpParser.enummemberdeclarations_return enummemberdeclarations()
			throws RecognitionException {
		CSharpParser.enummemberdeclarations_return retval =
			new CSharpParser.enummemberdeclarations_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.enummemberdeclaration_return enummemberdeclaration1130 =
			null;

		CSharpParser.cOMMA_return cOMMA1131 = null;

		CSharpParser.enummemberdeclaration_return enummemberdeclaration1132 =
			null;

		try {
			// ../rsc/CSharp.g3:2489:5: ( enummemberdeclaration ( cOMMA enummemberdeclaration )* )
			// ../rsc/CSharp.g3:2489:9: enummemberdeclaration ( cOMMA enummemberdeclaration )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_enummemberdeclaration_in_enummemberdeclarations16214);
				enummemberdeclaration1130 = enummemberdeclaration();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(
						root_0,
						enummemberdeclaration1130.getTree());
				// ../rsc/CSharp.g3:2489:31: ( cOMMA enummemberdeclaration )*
				loop278: do {
					int alt278 = 2;
					alt278 = this.dfa278.predict(this.input);
					switch (alt278) {
						case 1 :
						// ../rsc/CSharp.g3:2489:32: cOMMA enummemberdeclaration
							{
								pushFollow(FOLLOW_cOMMA_in_enummemberdeclarations16217);
								cOMMA1131 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1131.getTree());
								pushFollow(FOLLOW_enummemberdeclaration_in_enummemberdeclarations16219);
								enummemberdeclaration1132 =
									enummemberdeclaration();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										enummemberdeclaration1132.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "enummemberdeclarations"

	public static class enummemberdeclaration_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "enummemberdeclaration"
	// ../rsc/CSharp.g3:2492:1: enummemberdeclaration : ( ( attributes )? identifier aSSIGN constantexpression -> ^( EnumMemberDeclaration ( attributes )? identifier aSSIGN constantexpression ) | ( attributes )? identifier -> ^( EnumMemberDeclaration ( attributes )? identifier ) );
	public final CSharpParser.enummemberdeclaration_return enummemberdeclaration()
			throws RecognitionException {
		CSharpParser.enummemberdeclaration_return retval =
			new CSharpParser.enummemberdeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1133 = null;

		CSharpParser.identifier_return identifier1134 = null;

		CSharpParser.aSSIGN_return aSSIGN1135 = null;

		CSharpParser.constantexpression_return constantexpression1136 = null;

		CSharpParser.attributes_return attributes1137 = null;

		CSharpParser.identifier_return identifier1138 = null;

		RewriteRuleSubtreeStream stream_constantexpression =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constantexpression");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_aSSIGN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aSSIGN");
		try {
			// ../rsc/CSharp.g3:2493:5: ( ( attributes )? identifier aSSIGN constantexpression -> ^( EnumMemberDeclaration ( attributes )? identifier aSSIGN constantexpression ) | ( attributes )? identifier -> ^( EnumMemberDeclaration ( attributes )? identifier ) )
			int alt281 = 2;
			alt281 = this.dfa281.predict(this.input);
			switch (alt281) {
				case 1 :
				// ../rsc/CSharp.g3:2493:7: ( attributes )? identifier aSSIGN constantexpression
					{
						// ../rsc/CSharp.g3:2493:7: ( attributes )?
						int alt279 = 2;
						int LA279_0 = this.input.LA(1);

						if ((LA279_0 == LBRACKET)) {
							alt279 = 1;
						}
						switch (alt279) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: attributes
								{
									pushFollow(FOLLOW_attributes_in_enummemberdeclaration16238);
									attributes1133 = attributes();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_attributes.add(attributes1133
											.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_identifier_in_enummemberdeclaration16241);
						identifier1134 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier1134.getTree());
						pushFollow(FOLLOW_aSSIGN_in_enummemberdeclaration16243);
						aSSIGN1135 = aSSIGN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_aSSIGN.add(aSSIGN1135.getTree());
						pushFollow(FOLLOW_constantexpression_in_enummemberdeclaration16245);
						constantexpression1136 = constantexpression();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constantexpression
								.add(constantexpression1136.getTree());

						// AST REWRITE
						// elements: identifier, aSSIGN, constantexpression, attributes
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2494:5: -> ^( EnumMemberDeclaration ( attributes )? identifier aSSIGN constantexpression )
							{
								// ../rsc/CSharp.g3:2494:8: ^( EnumMemberDeclaration ( attributes )? identifier aSSIGN constantexpression )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												EnumMemberDeclaration,
												"EnumMemberDeclaration"),
											root_1);

									// ../rsc/CSharp.g3:2494:32: ( attributes )?
									if (stream_attributes.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_attributes.nextTree());

									}
									stream_attributes.reset();
									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_aSSIGN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_constantexpression.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2495:4: ( attributes )? identifier
					{
						// ../rsc/CSharp.g3:2495:4: ( attributes )?
						int alt280 = 2;
						int LA280_0 = this.input.LA(1);

						if ((LA280_0 == LBRACKET)) {
							alt280 = 1;
						}
						switch (alt280) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: attributes
								{
									pushFollow(FOLLOW_attributes_in_enummemberdeclaration16269);
									attributes1137 = attributes();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_attributes.add(attributes1137
											.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_identifier_in_enummemberdeclaration16272);
						identifier1138 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_identifier.add(identifier1138.getTree());

						// AST REWRITE
						// elements: attributes, identifier
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2496:5: -> ^( EnumMemberDeclaration ( attributes )? identifier )
							{
								// ../rsc/CSharp.g3:2496:8: ^( EnumMemberDeclaration ( attributes )? identifier )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												EnumMemberDeclaration,
												"EnumMemberDeclaration"),
											root_1);

									// ../rsc/CSharp.g3:2496:32: ( attributes )?
									if (stream_attributes.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_attributes.nextTree());

									}
									stream_attributes.reset();
									this.adaptor.addChild(
										root_1,
										stream_identifier.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "enummemberdeclaration"

	public static class delegatedeclaration_return extends
			ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "delegatedeclaration"
	// ../rsc/CSharp.g3:2500:1: delegatedeclaration returns [String name] : ( attributes )? ( delegatemodifiers )? dELEGATE returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON -> ^( Delegate ( attributes )? ( delegatemodifiers )? dELEGATE returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON ) ;
	public final CSharpParser.delegatedeclaration_return delegatedeclaration()
			throws RecognitionException {
		CSharpParser.delegatedeclaration_return retval =
			new CSharpParser.delegatedeclaration_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1139 = null;

		CSharpParser.delegatemodifiers_return delegatemodifiers1140 = null;

		CSharpParser.dELEGATE_return dELEGATE1141 = null;

		CSharpParser.returntype_return returntype1142 = null;

		CSharpParser.identifier_return identifier1143 = null;

		CSharpParser.typeparameterlist_return typeparameterlist1144 = null;

		CSharpParser.lPAREN_return lPAREN1145 = null;

		CSharpParser.formalparameterlist_return formalparameterlist1146 = null;

		CSharpParser.rPAREN_return rPAREN1147 = null;

		CSharpParser.typeparameterconstraintsclauses_return typeparameterconstraintsclauses1148 =
			null;

		CSharpParser.sEMICOLON_return sEMICOLON1149 = null;

		RewriteRuleSubtreeStream stream_delegatemodifiers =
			new RewriteRuleSubtreeStream(this.adaptor, "rule delegatemodifiers");
		RewriteRuleSubtreeStream stream_typeparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameterlist");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_typeparameterconstraintsclauses =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule typeparameterconstraintsclauses");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_dELEGATE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule dELEGATE");
		RewriteRuleSubtreeStream stream_formalparameterlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule formalparameterlist");
		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_sEMICOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sEMICOLON");
		RewriteRuleSubtreeStream stream_returntype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule returntype");
		try {
			// ../rsc/CSharp.g3:2504:5: ( ( attributes )? ( delegatemodifiers )? dELEGATE returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON -> ^( Delegate ( attributes )? ( delegatemodifiers )? dELEGATE returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON ) )
			// ../rsc/CSharp.g3:2504:9: ( attributes )? ( delegatemodifiers )? dELEGATE returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON
			{
				// ../rsc/CSharp.g3:2504:9: ( attributes )?
				int alt282 = 2;
				int LA282_0 = this.input.LA(1);

				if ((LA282_0 == LBRACKET)) {
					alt282 = 1;
				}
				switch (alt282) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_delegatedeclaration16316);
							attributes1139 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes1139.getTree());

						}
						break;

				}

				// ../rsc/CSharp.g3:2504:21: ( delegatemodifiers )?
				int alt283 = 2;
				int LA283_0 = this.input.LA(1);

				if ((LA283_0 == INTERNAL || LA283_0 == NEW || (LA283_0 >= PRIVATE && LA283_0 <= PUBLIC))) {
					alt283 = 1;
				}
				switch (alt283) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: delegatemodifiers
						{
							pushFollow(FOLLOW_delegatemodifiers_in_delegatedeclaration16319);
							delegatemodifiers1140 = delegatemodifiers();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_delegatemodifiers
									.add(delegatemodifiers1140.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_dELEGATE_in_delegatedeclaration16322);
				dELEGATE1141 = dELEGATE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_dELEGATE.add(dELEGATE1141.getTree());
				pushFollow(FOLLOW_returntype_in_delegatedeclaration16324);
				returntype1142 = returntype();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_returntype.add(returntype1142.getTree());
				pushFollow(FOLLOW_identifier_in_delegatedeclaration16326);
				identifier1143 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1143.getTree());
				// ../rsc/CSharp.g3:2504:71: ( typeparameterlist )?
				int alt284 = 2;
				int LA284_0 = this.input.LA(1);

				if ((LA284_0 == LT)) {
					alt284 = 1;
				}
				switch (alt284) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterlist
						{
							pushFollow(FOLLOW_typeparameterlist_in_delegatedeclaration16328);
							typeparameterlist1144 = typeparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterlist
									.add(typeparameterlist1144.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_lPAREN_in_delegatedeclaration16337);
				lPAREN1145 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN1145.getTree());
				// ../rsc/CSharp.g3:2505:14: ( formalparameterlist )?
				int alt285 = 2;
				int LA285_0 = this.input.LA(1);

				if ((LA285_0 == LBRACKET || LA285_0 == BOOL || LA285_0 == BYTE
						|| LA285_0 == CHAR || LA285_0 == DECIMAL
						|| LA285_0 == DOUBLE || LA285_0 == FLOAT
						|| LA285_0 == INT || LA285_0 == LONG
						|| LA285_0 == OBJECT || LA285_0 == OUT
						|| LA285_0 == PARAMS || LA285_0 == REF
						|| LA285_0 == SBYTE || LA285_0 == SHORT
						|| LA285_0 == STRING
						|| (LA285_0 >= UINT && LA285_0 <= ULONG)
						|| LA285_0 == USHORT || (LA285_0 >= ADD && LA285_0 <= Ident))) {
					alt285 = 1;
				}
				switch (alt285) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: formalparameterlist
						{
							pushFollow(FOLLOW_formalparameterlist_in_delegatedeclaration16339);
							formalparameterlist1146 = formalparameterlist();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_formalparameterlist
									.add(formalparameterlist1146.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rPAREN_in_delegatedeclaration16342);
				rPAREN1147 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN1147.getTree());
				// ../rsc/CSharp.g3:2505:42: ( typeparameterconstraintsclauses )?
				int alt286 = 2;
				int LA286_0 = this.input.LA(1);

				if ((LA286_0 == WHERE)) {
					alt286 = 1;
				}
				switch (alt286) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: typeparameterconstraintsclauses
						{
							pushFollow(FOLLOW_typeparameterconstraintsclauses_in_delegatedeclaration16344);
							typeparameterconstraintsclauses1148 =
								typeparameterconstraintsclauses();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_typeparameterconstraintsclauses
									.add(typeparameterconstraintsclauses1148
										.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_sEMICOLON_in_delegatedeclaration16347);
				sEMICOLON1149 = sEMICOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_sEMICOLON.add(sEMICOLON1149.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(identifier1143 != null ? identifier1143.content : null);
				}

				// AST REWRITE
				// elements: lPAREN, attributes, sEMICOLON, dELEGATE, formalparameterlist, typeparameterconstraintsclauses, identifier, rPAREN, returntype, delegatemodifiers, typeparameterlist
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2507:5: -> ^( Delegate ( attributes )? ( delegatemodifiers )? dELEGATE returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON )
					{
						// ../rsc/CSharp.g3:2507:9: ^( Delegate ( attributes )? ( delegatemodifiers )? dELEGATE returntype identifier ( typeparameterlist )? lPAREN ( formalparameterlist )? rPAREN ( typeparameterconstraintsclauses )? sEMICOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Delegate, "Delegate"), root_1);

							// ../rsc/CSharp.g3:2507:20: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							// ../rsc/CSharp.g3:2507:32: ( delegatemodifiers )?
							if (stream_delegatemodifiers.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_delegatemodifiers.nextTree());

							}
							stream_delegatemodifiers.reset();
							this.adaptor
								.addChild(root_1, stream_dELEGATE.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_returntype.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							// ../rsc/CSharp.g3:2507:82: ( typeparameterlist )?
							if (stream_typeparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterlist.nextTree());

							}
							stream_typeparameterlist.reset();
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							// ../rsc/CSharp.g3:2508:14: ( formalparameterlist )?
							if (stream_formalparameterlist.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_formalparameterlist.nextTree());

							}
							stream_formalparameterlist.reset();
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());
							// ../rsc/CSharp.g3:2508:42: ( typeparameterconstraintsclauses )?
							if (stream_typeparameterconstraintsclauses
								.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_typeparameterconstraintsclauses
										.nextTree());

							}
							stream_typeparameterconstraintsclauses.reset();
							this.adaptor.addChild(
								root_1,
								stream_sEMICOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
			if (this.state.backtracking == 0) {

				this.tokenNameMap.put(((Object) retval.tree), retval.name);

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "delegatedeclaration"

	public static class delegatemodifiers_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "delegatemodifiers"
	// ../rsc/CSharp.g3:2511:1: delegatemodifiers : ( delegatemodifier )+ -> ^( Modifiers ( delegatemodifier )+ ) ;
	public final CSharpParser.delegatemodifiers_return delegatemodifiers()
			throws RecognitionException {
		CSharpParser.delegatemodifiers_return retval =
			new CSharpParser.delegatemodifiers_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.delegatemodifier_return delegatemodifier1150 = null;

		RewriteRuleSubtreeStream stream_delegatemodifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule delegatemodifier");
		try {
			// ../rsc/CSharp.g3:2512:5: ( ( delegatemodifier )+ -> ^( Modifiers ( delegatemodifier )+ ) )
			// ../rsc/CSharp.g3:2512:9: ( delegatemodifier )+
			{
				// ../rsc/CSharp.g3:2512:9: ( delegatemodifier )+
				int cnt287 = 0;
				loop287: do {
					int alt287 = 2;
					int LA287_0 = this.input.LA(1);

					if ((LA287_0 == INTERNAL || LA287_0 == NEW || (LA287_0 >= PRIVATE && LA287_0 <= PUBLIC))) {
						alt287 = 1;
					}

					switch (alt287) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: delegatemodifier
							{
								pushFollow(FOLLOW_delegatemodifier_in_delegatemodifiers16418);
								delegatemodifier1150 = delegatemodifier();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_delegatemodifier
										.add(delegatemodifier1150.getTree());

							}
							break;

						default :
							if (cnt287 >= 1)
								break loop287;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(287, this.input);
							throw eee;
					}
					cnt287++;
				}
				while (true);

				// AST REWRITE
				// elements: delegatemodifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2513:5: -> ^( Modifiers ( delegatemodifier )+ )
					{
						// ../rsc/CSharp.g3:2513:8: ^( Modifiers ( delegatemodifier )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Modifiers, "Modifiers"), root_1);

							if (!(stream_delegatemodifier.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_delegatemodifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_delegatemodifier.nextTree());

							}
							stream_delegatemodifier.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "delegatemodifiers"

	public static class delegatemodifier_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "delegatemodifier"
	// ../rsc/CSharp.g3:2516:1: delegatemodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE );
	public final CSharpParser.delegatemodifier_return delegatemodifier()
			throws RecognitionException {
		CSharpParser.delegatemodifier_return retval =
			new CSharpParser.delegatemodifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW1151 = null;

		CSharpParser.pUBLIC_return pUBLIC1152 = null;

		CSharpParser.pROTECTED_return pROTECTED1153 = null;

		CSharpParser.iNTERNAL_return iNTERNAL1154 = null;

		CSharpParser.pRIVATE_return pRIVATE1155 = null;

		try {
			// ../rsc/CSharp.g3:2517:5: ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE )
			int alt288 = 5;
			switch (this.input.LA(1)) {
				case NEW :
					{
						alt288 = 1;
					}
					break;
				case PUBLIC :
					{
						alt288 = 2;
					}
					break;
				case PROTECTED :
					{
						alt288 = 3;
					}
					break;
				case INTERNAL :
					{
						alt288 = 4;
					}
					break;
				case PRIVATE :
					{
						alt288 = 5;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 288, 0, this.input);

					throw nvae;
			}

			switch (alt288) {
				case 1 :
				// ../rsc/CSharp.g3:2517:9: nEW
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nEW_in_delegatemodifier16451);
						nEW1151 = nEW();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nEW1151.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2518:10: pUBLIC
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pUBLIC_in_delegatemodifier16462);
						pUBLIC1152 = pUBLIC();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pUBLIC1152.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2519:9: pROTECTED
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pROTECTED_in_delegatemodifier16472);
						pROTECTED1153 = pROTECTED();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pROTECTED1153.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2520:9: iNTERNAL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_iNTERNAL_in_delegatemodifier16482);
						iNTERNAL1154 = iNTERNAL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, iNTERNAL1154.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2521:9: pRIVATE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_pRIVATE_in_delegatemodifier16492);
						pRIVATE1155 = pRIVATE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, pRIVATE1155.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "delegatemodifier"

	public static class globalattributes_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "globalattributes"
	// ../rsc/CSharp.g3:2525:1: globalattributes : ( globalattributesection )+ -> ^( GlobalAttributes ( globalattributesection )+ ) ;
	public final CSharpParser.globalattributes_return globalattributes()
			throws RecognitionException {
		CSharpParser.globalattributes_return retval =
			new CSharpParser.globalattributes_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.globalattributesection_return globalattributesection1156 =
			null;

		RewriteRuleSubtreeStream stream_globalattributesection =
			new RewriteRuleSubtreeStream(this.adaptor, "rule globalattributesection");
		try {
			// ../rsc/CSharp.g3:2526:5: ( ( globalattributesection )+ -> ^( GlobalAttributes ( globalattributesection )+ ) )
			// ../rsc/CSharp.g3:2526:9: ( globalattributesection )+
			{
				// ../rsc/CSharp.g3:2526:9: ( globalattributesection )+
				int cnt289 = 0;
				loop289: do {
					int alt289 = 2;
					alt289 = this.dfa289.predict(this.input);
					switch (alt289) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: globalattributesection
							{
								pushFollow(FOLLOW_globalattributesection_in_globalattributes16512);
								globalattributesection1156 =
									globalattributesection();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_globalattributesection
										.add(globalattributesection1156
											.getTree());

							}
							break;

						default :
							if (cnt289 >= 1)
								break loop289;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(289, this.input);
							throw eee;
					}
					cnt289++;
				}
				while (true);

				// AST REWRITE
				// elements: globalattributesection
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2527:5: -> ^( GlobalAttributes ( globalattributesection )+ )
					{
						// ../rsc/CSharp.g3:2527:8: ^( GlobalAttributes ( globalattributesection )+ )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										GlobalAttributes,
										"GlobalAttributes"), root_1);

							if (!(stream_globalattributesection.hasNext())) {
								throw new RewriteEarlyExitException();
							}
							while (stream_globalattributesection.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_globalattributesection.nextTree());

							}
							stream_globalattributesection.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "globalattributes"

	public static class globalattributesection_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "globalattributesection"
	// ../rsc/CSharp.g3:2532:1: globalattributesection : ( lBRACKET globalattributetargetspecifier attributelist rBRACKET -> ^( GlobalAttributeSection lBRACKET globalattributetargetspecifier attributelist rBRACKET ) | lBRACKET globalattributetargetspecifier attributelist cOMMA rBRACKET -> ^( GlobalAttributeSection lBRACKET globalattributetargetspecifier attributelist cOMMA rBRACKET ) );
	public final CSharpParser.globalattributesection_return globalattributesection()
			throws RecognitionException {
		CSharpParser.globalattributesection_return retval =
			new CSharpParser.globalattributesection_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACKET_return lBRACKET1157 = null;

		CSharpParser.globalattributetargetspecifier_return globalattributetargetspecifier1158 =
			null;

		CSharpParser.attributelist_return attributelist1159 = null;

		CSharpParser.rBRACKET_return rBRACKET1160 = null;

		CSharpParser.lBRACKET_return lBRACKET1161 = null;

		CSharpParser.globalattributetargetspecifier_return globalattributetargetspecifier1162 =
			null;

		CSharpParser.attributelist_return attributelist1163 = null;

		CSharpParser.cOMMA_return cOMMA1164 = null;

		CSharpParser.rBRACKET_return rBRACKET1165 = null;

		RewriteRuleSubtreeStream stream_attributelist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributelist");
		RewriteRuleSubtreeStream stream_lBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACKET");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		RewriteRuleSubtreeStream stream_rBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACKET");
		RewriteRuleSubtreeStream stream_globalattributetargetspecifier =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule globalattributetargetspecifier");
		try {
			// ../rsc/CSharp.g3:2533:5: ( lBRACKET globalattributetargetspecifier attributelist rBRACKET -> ^( GlobalAttributeSection lBRACKET globalattributetargetspecifier attributelist rBRACKET ) | lBRACKET globalattributetargetspecifier attributelist cOMMA rBRACKET -> ^( GlobalAttributeSection lBRACKET globalattributetargetspecifier attributelist cOMMA rBRACKET ) )
			int alt290 = 2;
			int LA290_0 = this.input.LA(1);

			if ((LA290_0 == LBRACKET)) {
				this.input.LA(2);

				if ((synpred630_CSharp())) {
					alt290 = 1;
				}
				else if ((true)) {
					alt290 = 2;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 290, 0, this.input);

				throw nvae;
			}
			switch (alt290) {
				case 1 :
				// ../rsc/CSharp.g3:2533:9: lBRACKET globalattributetargetspecifier attributelist rBRACKET
					{
						pushFollow(FOLLOW_lBRACKET_in_globalattributesection16547);
						lBRACKET1157 = lBRACKET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACKET.add(lBRACKET1157.getTree());
						pushFollow(FOLLOW_globalattributetargetspecifier_in_globalattributesection16549);
						globalattributetargetspecifier1158 =
							globalattributetargetspecifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_globalattributetargetspecifier
								.add(globalattributetargetspecifier1158
									.getTree());
						pushFollow(FOLLOW_attributelist_in_globalattributesection16551);
						attributelist1159 = attributelist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_attributelist.add(attributelist1159
								.getTree());
						pushFollow(FOLLOW_rBRACKET_in_globalattributesection16553);
						rBRACKET1160 = rBRACKET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACKET.add(rBRACKET1160.getTree());

						// AST REWRITE
						// elements: globalattributetargetspecifier, lBRACKET, attributelist, rBRACKET
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2534:5: -> ^( GlobalAttributeSection lBRACKET globalattributetargetspecifier attributelist rBRACKET )
							{
								// ../rsc/CSharp.g3:2534:8: ^( GlobalAttributeSection lBRACKET globalattributetargetspecifier attributelist rBRACKET )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												GlobalAttributeSection,
												"GlobalAttributeSection"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lBRACKET.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_globalattributetargetspecifier
											.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_attributelist.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rBRACKET.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2535:9: lBRACKET globalattributetargetspecifier attributelist cOMMA rBRACKET
					{
						pushFollow(FOLLOW_lBRACKET_in_globalattributesection16581);
						lBRACKET1161 = lBRACKET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lBRACKET.add(lBRACKET1161.getTree());
						pushFollow(FOLLOW_globalattributetargetspecifier_in_globalattributesection16583);
						globalattributetargetspecifier1162 =
							globalattributetargetspecifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_globalattributetargetspecifier
								.add(globalattributetargetspecifier1162
									.getTree());
						pushFollow(FOLLOW_attributelist_in_globalattributesection16585);
						attributelist1163 = attributelist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_attributelist.add(attributelist1163
								.getTree());
						pushFollow(FOLLOW_cOMMA_in_globalattributesection16587);
						cOMMA1164 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA1164.getTree());
						pushFollow(FOLLOW_rBRACKET_in_globalattributesection16589);
						rBRACKET1165 = rBRACKET();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rBRACKET.add(rBRACKET1165.getTree());

						// AST REWRITE
						// elements: attributelist, lBRACKET, cOMMA, globalattributetargetspecifier, rBRACKET
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2536:5: -> ^( GlobalAttributeSection lBRACKET globalattributetargetspecifier attributelist cOMMA rBRACKET )
							{
								// ../rsc/CSharp.g3:2536:8: ^( GlobalAttributeSection lBRACKET globalattributetargetspecifier attributelist cOMMA rBRACKET )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												GlobalAttributeSection,
												"GlobalAttributeSection"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lBRACKET.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_globalattributetargetspecifier
											.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_attributelist.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rBRACKET.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "globalattributesection"

	public static class globalattributetargetspecifier_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "globalattributetargetspecifier"
	// ../rsc/CSharp.g3:2539:1: globalattributetargetspecifier : globalattributetarget cOLON -> ^( GlobalAttributeTargetSpecifier globalattributetarget cOLON ) ;
	public final CSharpParser.globalattributetargetspecifier_return globalattributetargetspecifier()
			throws RecognitionException {
		CSharpParser.globalattributetargetspecifier_return retval =
			new CSharpParser.globalattributetargetspecifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.globalattributetarget_return globalattributetarget1166 =
			null;

		CSharpParser.cOLON_return cOLON1167 = null;

		RewriteRuleSubtreeStream stream_cOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOLON");
		RewriteRuleSubtreeStream stream_globalattributetarget =
			new RewriteRuleSubtreeStream(this.adaptor, "rule globalattributetarget");
		try {
			// ../rsc/CSharp.g3:2540:5: ( globalattributetarget cOLON -> ^( GlobalAttributeTargetSpecifier globalattributetarget cOLON ) )
			// ../rsc/CSharp.g3:2540:9: globalattributetarget cOLON
			{
				pushFollow(FOLLOW_globalattributetarget_in_globalattributetargetspecifier16628);
				globalattributetarget1166 = globalattributetarget();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_globalattributetarget.add(globalattributetarget1166
						.getTree());
				pushFollow(FOLLOW_cOLON_in_globalattributetargetspecifier16630);
				cOLON1167 = cOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cOLON.add(cOLON1167.getTree());

				// AST REWRITE
				// elements: globalattributetarget, cOLON
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2541:5: -> ^( GlobalAttributeTargetSpecifier globalattributetarget cOLON )
					{
						// ../rsc/CSharp.g3:2541:8: ^( GlobalAttributeTargetSpecifier globalattributetarget cOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										GlobalAttributeTargetSpecifier,
										"GlobalAttributeTargetSpecifier"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_globalattributetarget.nextTree());
							this.adaptor.addChild(root_1, stream_cOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "globalattributetargetspecifier"

	public static class globalattributetarget_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "globalattributetarget"
	// ../rsc/CSharp.g3:2544:1: globalattributetarget : ( identifier | keyword );
	public final CSharpParser.globalattributetarget_return globalattributetarget()
			throws RecognitionException {
		CSharpParser.globalattributetarget_return retval =
			new CSharpParser.globalattributetarget_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier1168 = null;

		CSharpParser.keyword_return keyword1169 = null;

		try {
			// ../rsc/CSharp.g3:2545:5: ( identifier | keyword )
			int alt291 = 2;
			int LA291_0 = this.input.LA(1);

			if (((LA291_0 >= ADD && LA291_0 <= Ident))) {
				alt291 = 1;
			}
			else if (((LA291_0 >= ABSTRACT && LA291_0 <= WHILE))) {
				alt291 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 291, 0, this.input);

				throw nvae;
			}
			switch (alt291) {
				case 1 :
				// ../rsc/CSharp.g3:2545:9: identifier
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_identifier_in_globalattributetarget16663);
						identifier1168 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, identifier1168.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2546:9: keyword
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_keyword_in_globalattributetarget16673);
						keyword1169 = keyword();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, keyword1169.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "globalattributetarget"

	public static class attributes_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributes"
	// ../rsc/CSharp.g3:2549:1: attributes : attributesections -> ^( Attributes attributesections ) ;
	public final CSharpParser.attributes_return attributes()
			throws RecognitionException {
		CSharpParser.attributes_return retval =
			new CSharpParser.attributes_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributesections_return attributesections1170 = null;

		RewriteRuleSubtreeStream stream_attributesections =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributesections");
		try {
			// ../rsc/CSharp.g3:2550:5: ( attributesections -> ^( Attributes attributesections ) )
			// ../rsc/CSharp.g3:2550:9: attributesections
			{
				pushFollow(FOLLOW_attributesections_in_attributes16692);
				attributesections1170 = attributesections();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_attributesections.add(attributesections1170
						.getTree());

				// AST REWRITE
				// elements: attributesections
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2551:5: -> ^( Attributes attributesections )
					{
						// ../rsc/CSharp.g3:2551:8: ^( Attributes attributesections )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Attributes, "Attributes"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_attributesections.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributes"

	public static class attributesections_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributesections"
	// ../rsc/CSharp.g3:2554:1: attributesections : ( attributesection )+ ;
	public final CSharpParser.attributesections_return attributesections()
			throws RecognitionException {
		CSharpParser.attributesections_return retval =
			new CSharpParser.attributesections_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributesection_return attributesection1171 = null;

		try {
			// ../rsc/CSharp.g3:2555:5: ( ( attributesection )+ )
			// ../rsc/CSharp.g3:2555:9: ( attributesection )+
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:2555:9: ( attributesection )+
				int cnt292 = 0;
				loop292: do {
					int alt292 = 2;
					int LA292_0 = this.input.LA(1);

					if ((LA292_0 == LBRACKET)) {
						alt292 = 1;
					}

					switch (alt292) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: attributesection
							{
								pushFollow(FOLLOW_attributesection_in_attributesections16724);
								attributesection1171 = attributesection();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										attributesection1171.getTree());

							}
							break;

						default :
							if (cnt292 >= 1)
								break loop292;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(292, this.input);
							throw eee;
					}
					cnt292++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributesections"

	public static class attributesection_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributesection"
	// ../rsc/CSharp.g3:2558:1: attributesection : lBRACKET ( attributetargetspecifier )? attributelist ( cOMMA )? rBRACKET -> ^( AttributeSection lBRACKET ( attributetargetspecifier )? attributelist ( cOMMA )? rBRACKET ) ;
	public final CSharpParser.attributesection_return attributesection()
			throws RecognitionException {
		CSharpParser.attributesection_return retval =
			new CSharpParser.attributesection_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lBRACKET_return lBRACKET1172 = null;

		CSharpParser.attributetargetspecifier_return attributetargetspecifier1173 =
			null;

		CSharpParser.attributelist_return attributelist1174 = null;

		CSharpParser.cOMMA_return cOMMA1175 = null;

		CSharpParser.rBRACKET_return rBRACKET1176 = null;

		RewriteRuleSubtreeStream stream_attributelist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributelist");
		RewriteRuleSubtreeStream stream_lBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lBRACKET");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		RewriteRuleSubtreeStream stream_rBRACKET =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rBRACKET");
		RewriteRuleSubtreeStream stream_attributetargetspecifier =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule attributetargetspecifier");
		try {
			// ../rsc/CSharp.g3:2559:5: ( lBRACKET ( attributetargetspecifier )? attributelist ( cOMMA )? rBRACKET -> ^( AttributeSection lBRACKET ( attributetargetspecifier )? attributelist ( cOMMA )? rBRACKET ) )
			// ../rsc/CSharp.g3:2559:9: lBRACKET ( attributetargetspecifier )? attributelist ( cOMMA )? rBRACKET
			{
				pushFollow(FOLLOW_lBRACKET_in_attributesection16744);
				lBRACKET1172 = lBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lBRACKET.add(lBRACKET1172.getTree());
				// ../rsc/CSharp.g3:2559:18: ( attributetargetspecifier )?
				int alt293 = 2;
				alt293 = this.dfa293.predict(this.input);
				switch (alt293) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributetargetspecifier
						{
							pushFollow(FOLLOW_attributetargetspecifier_in_attributesection16746);
							attributetargetspecifier1173 =
								attributetargetspecifier();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributetargetspecifier
									.add(attributetargetspecifier1173.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_attributelist_in_attributesection16749);
				attributelist1174 = attributelist();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_attributelist.add(attributelist1174.getTree());
				// ../rsc/CSharp.g3:2559:58: ( cOMMA )?
				int alt294 = 2;
				int LA294_0 = this.input.LA(1);

				if ((LA294_0 == COMMA)) {
					alt294 = 1;
				}
				switch (alt294) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: cOMMA
						{
							pushFollow(FOLLOW_cOMMA_in_attributesection16751);
							cOMMA1175 = cOMMA();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_cOMMA.add(cOMMA1175.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_rBRACKET_in_attributesection16754);
				rBRACKET1176 = rBRACKET();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rBRACKET.add(rBRACKET1176.getTree());

				// AST REWRITE
				// elements: cOMMA, attributelist, attributetargetspecifier, rBRACKET, lBRACKET
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2560:2: -> ^( AttributeSection lBRACKET ( attributetargetspecifier )? attributelist ( cOMMA )? rBRACKET )
					{
						// ../rsc/CSharp.g3:2560:5: ^( AttributeSection lBRACKET ( attributetargetspecifier )? attributelist ( cOMMA )? rBRACKET )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										AttributeSection,
										"AttributeSection"), root_1);

							this.adaptor
								.addChild(root_1, stream_lBRACKET.nextTree());
							// ../rsc/CSharp.g3:2560:33: ( attributetargetspecifier )?
							if (stream_attributetargetspecifier.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributetargetspecifier.nextTree());

							}
							stream_attributetargetspecifier.reset();
							this.adaptor.addChild(
								root_1,
								stream_attributelist.nextTree());
							// ../rsc/CSharp.g3:2560:73: ( cOMMA )?
							if (stream_cOMMA.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_cOMMA.nextTree());

							}
							stream_cOMMA.reset();
							this.adaptor
								.addChild(root_1, stream_rBRACKET.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributesection"

	public static class attributetargetspecifier_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributetargetspecifier"
	// ../rsc/CSharp.g3:2563:1: attributetargetspecifier : attributetarget cOLON -> ^( AttributeTargetSpecifier attributetarget cOLON ) ;
	public final CSharpParser.attributetargetspecifier_return attributetargetspecifier()
			throws RecognitionException {
		CSharpParser.attributetargetspecifier_return retval =
			new CSharpParser.attributetargetspecifier_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributetarget_return attributetarget1177 = null;

		CSharpParser.cOLON_return cOLON1178 = null;

		RewriteRuleSubtreeStream stream_cOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOLON");
		RewriteRuleSubtreeStream stream_attributetarget =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributetarget");
		try {
			// ../rsc/CSharp.g3:2564:5: ( attributetarget cOLON -> ^( AttributeTargetSpecifier attributetarget cOLON ) )
			// ../rsc/CSharp.g3:2564:9: attributetarget cOLON
			{
				pushFollow(FOLLOW_attributetarget_in_attributetargetspecifier16792);
				attributetarget1177 = attributetarget();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_attributetarget.add(attributetarget1177.getTree());
				pushFollow(FOLLOW_cOLON_in_attributetargetspecifier16794);
				cOLON1178 = cOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cOLON.add(cOLON1178.getTree());

				// AST REWRITE
				// elements: cOLON, attributetarget
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2565:5: -> ^( AttributeTargetSpecifier attributetarget cOLON )
					{
						// ../rsc/CSharp.g3:2565:8: ^( AttributeTargetSpecifier attributetarget cOLON )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										AttributeTargetSpecifier,
										"AttributeTargetSpecifier"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_attributetarget.nextTree());
							this.adaptor.addChild(root_1, stream_cOLON.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributetargetspecifier"

	public static class attributetarget_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributetarget"
	// ../rsc/CSharp.g3:2568:1: attributetarget : ( identifier | keyword );
	public final CSharpParser.attributetarget_return attributetarget()
			throws RecognitionException {
		CSharpParser.attributetarget_return retval =
			new CSharpParser.attributetarget_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier1179 = null;

		CSharpParser.keyword_return keyword1180 = null;

		try {
			// ../rsc/CSharp.g3:2569:5: ( identifier | keyword )
			int alt295 = 2;
			int LA295_0 = this.input.LA(1);

			if (((LA295_0 >= ADD && LA295_0 <= Ident))) {
				alt295 = 1;
			}
			else if (((LA295_0 >= ABSTRACT && LA295_0 <= WHILE))) {
				alt295 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 295, 0, this.input);

				throw nvae;
			}
			switch (alt295) {
				case 1 :
				// ../rsc/CSharp.g3:2569:9: identifier
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_identifier_in_attributetarget16827);
						identifier1179 = identifier();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, identifier1179.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2570:9: keyword
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_keyword_in_attributetarget16837);
						keyword1180 = keyword();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, keyword1180.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributetarget"

	public static class attributelist_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributelist"
	// ../rsc/CSharp.g3:2573:1: attributelist : attribute ( cOMMA attribute )* ;
	public final CSharpParser.attributelist_return attributelist()
			throws RecognitionException {
		CSharpParser.attributelist_return retval =
			new CSharpParser.attributelist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attribute_return attribute1181 = null;

		CSharpParser.cOMMA_return cOMMA1182 = null;

		CSharpParser.attribute_return attribute1183 = null;

		try {
			// ../rsc/CSharp.g3:2574:5: ( attribute ( cOMMA attribute )* )
			// ../rsc/CSharp.g3:2574:9: attribute ( cOMMA attribute )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_attribute_in_attributelist16857);
				attribute1181 = attribute();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, attribute1181.getTree());
				// ../rsc/CSharp.g3:2574:19: ( cOMMA attribute )*
				loop296: do {
					int alt296 = 2;
					alt296 = this.dfa296.predict(this.input);
					switch (alt296) {
						case 1 :
						// ../rsc/CSharp.g3:2574:20: cOMMA attribute
							{
								pushFollow(FOLLOW_cOMMA_in_attributelist16860);
								cOMMA1182 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1182.getTree());
								pushFollow(FOLLOW_attribute_in_attributelist16862);
								attribute1183 = attribute();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										attribute1183.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributelist"

	public static class attribute_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attribute"
	// ../rsc/CSharp.g3:2577:1: attribute : attributename ( attributearguments )? -> ^( Attribute attributename ( attributearguments )? ) ;
	public final CSharpParser.attribute_return attribute()
			throws RecognitionException {
		CSharpParser.attribute_return retval =
			new CSharpParser.attribute_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributename_return attributename1184 = null;

		CSharpParser.attributearguments_return attributearguments1185 = null;

		RewriteRuleSubtreeStream stream_attributename =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributename");
		RewriteRuleSubtreeStream stream_attributearguments =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributearguments");
		try {
			// ../rsc/CSharp.g3:2578:5: ( attributename ( attributearguments )? -> ^( Attribute attributename ( attributearguments )? ) )
			// ../rsc/CSharp.g3:2578:9: attributename ( attributearguments )?
			{
				pushFollow(FOLLOW_attributename_in_attribute16883);
				attributename1184 = attributename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_attributename.add(attributename1184.getTree());
				// ../rsc/CSharp.g3:2578:23: ( attributearguments )?
				int alt297 = 2;
				int LA297_0 = this.input.LA(1);

				if ((LA297_0 == LPAREN)) {
					alt297 = 1;
				}
				switch (alt297) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributearguments
						{
							pushFollow(FOLLOW_attributearguments_in_attribute16885);
							attributearguments1185 = attributearguments();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributearguments
									.add(attributearguments1185.getTree());

						}
						break;

				}

				// AST REWRITE
				// elements: attributearguments, attributename
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2579:5: -> ^( Attribute attributename ( attributearguments )? )
					{
						// ../rsc/CSharp.g3:2579:8: ^( Attribute attributename ( attributearguments )? )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(Attribute, "Attribute"), root_1);

							this.adaptor.addChild(
								root_1,
								stream_attributename.nextTree());
							// ../rsc/CSharp.g3:2579:34: ( attributearguments )?
							if (stream_attributearguments.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributearguments.nextTree());

							}
							stream_attributearguments.reset();

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attribute"

	public static class attributename_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributename"
	// ../rsc/CSharp.g3:2582:1: attributename : typename ;
	public final CSharpParser.attributename_return attributename()
			throws RecognitionException {
		CSharpParser.attributename_return retval =
			new CSharpParser.attributename_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.typename_return typename1186 = null;

		try {
			// ../rsc/CSharp.g3:2583:5: ( typename )
			// ../rsc/CSharp.g3:2583:9: typename
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_typename_in_attributename16920);
				typename1186 = typename();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, typename1186.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributename"

	public static class attributearguments_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributearguments"
	// ../rsc/CSharp.g3:2586:1: attributearguments : ( lPAREN ( positionalargumentlist )? rPAREN -> ^( AttributeArguments lPAREN ( positionalargumentlist )? rPAREN ) | lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN -> ^( AttributeArguments lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN ) | lPAREN namedargumentlist rPAREN -> ^( AttributeArguments lPAREN namedargumentlist rPAREN ) );
	public final CSharpParser.attributearguments_return attributearguments()
			throws RecognitionException {
		CSharpParser.attributearguments_return retval =
			new CSharpParser.attributearguments_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lPAREN_return lPAREN1187 = null;

		CSharpParser.positionalargumentlist_return positionalargumentlist1188 =
			null;

		CSharpParser.rPAREN_return rPAREN1189 = null;

		CSharpParser.lPAREN_return lPAREN1190 = null;

		CSharpParser.positionalargumentlist_return positionalargumentlist1191 =
			null;

		CSharpParser.cOMMA_return cOMMA1192 = null;

		CSharpParser.namedargumentlist_return namedargumentlist1193 = null;

		CSharpParser.rPAREN_return rPAREN1194 = null;

		CSharpParser.lPAREN_return lPAREN1195 = null;

		CSharpParser.namedargumentlist_return namedargumentlist1196 = null;

		CSharpParser.rPAREN_return rPAREN1197 = null;

		RewriteRuleSubtreeStream stream_positionalargumentlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule positionalargumentlist");
		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		RewriteRuleSubtreeStream stream_namedargumentlist =
			new RewriteRuleSubtreeStream(this.adaptor, "rule namedargumentlist");
		try {
			// ../rsc/CSharp.g3:2587:5: ( lPAREN ( positionalargumentlist )? rPAREN -> ^( AttributeArguments lPAREN ( positionalargumentlist )? rPAREN ) | lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN -> ^( AttributeArguments lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN ) | lPAREN namedargumentlist rPAREN -> ^( AttributeArguments lPAREN namedargumentlist rPAREN ) )
			int alt299 = 3;
			int LA299_0 = this.input.LA(1);

			if ((LA299_0 == LPAREN)) {
				this.input.LA(2);

				if ((synpred639_CSharp())) {
					alt299 = 1;
				}
				else if ((synpred640_CSharp())) {
					alt299 = 2;
				}
				else if ((true)) {
					alt299 = 3;
				}
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 299, 0, this.input);

				throw nvae;
			}
			switch (alt299) {
				case 1 :
				// ../rsc/CSharp.g3:2587:9: lPAREN ( positionalargumentlist )? rPAREN
					{
						pushFollow(FOLLOW_lPAREN_in_attributearguments16939);
						lPAREN1187 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN1187.getTree());
						// ../rsc/CSharp.g3:2587:16: ( positionalargumentlist )?
						int alt298 = 2;
						int LA298_0 = this.input.LA(1);

						if ((LA298_0 == LPAREN
								|| (LA298_0 >= PLUS && LA298_0 <= MINUS)
								|| (LA298_0 >= EXCLAM && LA298_0 <= TILDE)
								|| (LA298_0 >= INCREMENT && LA298_0 <= DECREMENT)
								|| (LA298_0 >= BASE && LA298_0 <= BOOL)
								|| LA298_0 == BYTE
								|| (LA298_0 >= CHAR && LA298_0 <= CHECKED)
								|| (LA298_0 >= DECIMAL && LA298_0 <= DELEGATE)
								|| LA298_0 == DOUBLE || LA298_0 == FALSE
								|| LA298_0 == FLOAT || LA298_0 == INT
								|| LA298_0 == LONG
								|| (LA298_0 >= NEW && LA298_0 <= OBJECT)
								|| LA298_0 == SBYTE || LA298_0 == SHORT
								|| LA298_0 == STRING || LA298_0 == THIS
								|| LA298_0 == TRUE
								|| (LA298_0 >= TYPEOF && LA298_0 <= UNCHECKED)
								|| LA298_0 == USHORT || (LA298_0 >= ADD && LA298_0 <= Stringliteral))) {
							alt298 = 1;
						}
						switch (alt298) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: positionalargumentlist
								{
									pushFollow(FOLLOW_positionalargumentlist_in_attributearguments16941);
									positionalargumentlist1188 =
										positionalargumentlist();

									this.state._fsp--;
									if (this.state.failed)
										return retval;
									if (this.state.backtracking == 0)
										stream_positionalargumentlist
											.add(positionalargumentlist1188
												.getTree());

								}
								break;

						}

						pushFollow(FOLLOW_rPAREN_in_attributearguments16944);
						rPAREN1189 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN1189.getTree());

						// AST REWRITE
						// elements: rPAREN, lPAREN, positionalargumentlist
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2588:5: -> ^( AttributeArguments lPAREN ( positionalargumentlist )? rPAREN )
							{
								// ../rsc/CSharp.g3:2588:8: ^( AttributeArguments lPAREN ( positionalargumentlist )? rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												AttributeArguments,
												"AttributeArguments"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									// ../rsc/CSharp.g3:2588:36: ( positionalargumentlist )?
									if (stream_positionalargumentlist.hasNext()) {
										this.adaptor.addChild(
											root_1,
											stream_positionalargumentlist
												.nextTree());

									}
									stream_positionalargumentlist.reset();
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2589:9: lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN
					{
						pushFollow(FOLLOW_lPAREN_in_attributearguments16971);
						lPAREN1190 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN1190.getTree());
						pushFollow(FOLLOW_positionalargumentlist_in_attributearguments16973);
						positionalargumentlist1191 = positionalargumentlist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_positionalargumentlist
								.add(positionalargumentlist1191.getTree());
						pushFollow(FOLLOW_cOMMA_in_attributearguments16975);
						cOMMA1192 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA1192.getTree());
						pushFollow(FOLLOW_namedargumentlist_in_attributearguments16977);
						namedargumentlist1193 = namedargumentlist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_namedargumentlist.add(namedargumentlist1193
								.getTree());
						pushFollow(FOLLOW_rPAREN_in_attributearguments16979);
						rPAREN1194 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN1194.getTree());

						// AST REWRITE
						// elements: cOMMA, positionalargumentlist, rPAREN, namedargumentlist, lPAREN
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2590:5: -> ^( AttributeArguments lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN )
							{
								// ../rsc/CSharp.g3:2590:8: ^( AttributeArguments lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												AttributeArguments,
												"AttributeArguments"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_positionalargumentlist
											.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_namedargumentlist.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2591:9: lPAREN namedargumentlist rPAREN
					{
						pushFollow(FOLLOW_lPAREN_in_attributearguments17009);
						lPAREN1195 = lPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_lPAREN.add(lPAREN1195.getTree());
						pushFollow(FOLLOW_namedargumentlist_in_attributearguments17011);
						namedargumentlist1196 = namedargumentlist();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_namedargumentlist.add(namedargumentlist1196
								.getTree());
						pushFollow(FOLLOW_rPAREN_in_attributearguments17013);
						rPAREN1197 = rPAREN();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_rPAREN.add(rPAREN1197.getTree());

						// AST REWRITE
						// elements: rPAREN, lPAREN, namedargumentlist
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2592:5: -> ^( AttributeArguments lPAREN namedargumentlist rPAREN )
							{
								// ../rsc/CSharp.g3:2592:8: ^( AttributeArguments lPAREN namedargumentlist rPAREN )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												AttributeArguments,
												"AttributeArguments"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_lPAREN.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_namedargumentlist.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_rPAREN.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributearguments"

	public static class positionalargumentlist_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "positionalargumentlist"
	// ../rsc/CSharp.g3:2595:1: positionalargumentlist : positionalargument ( cOMMA positionalargument )* ;
	public final CSharpParser.positionalargumentlist_return positionalargumentlist()
			throws RecognitionException {
		CSharpParser.positionalargumentlist_return retval =
			new CSharpParser.positionalargumentlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.positionalargument_return positionalargument1198 = null;

		CSharpParser.cOMMA_return cOMMA1199 = null;

		CSharpParser.positionalargument_return positionalargument1200 = null;

		try {
			// ../rsc/CSharp.g3:2596:5: ( positionalargument ( cOMMA positionalargument )* )
			// ../rsc/CSharp.g3:2596:9: positionalargument ( cOMMA positionalargument )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_positionalargument_in_positionalargumentlist17049);
				positionalargument1198 = positionalargument();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, positionalargument1198.getTree());
				// ../rsc/CSharp.g3:2596:28: ( cOMMA positionalargument )*
				loop300: do {
					int alt300 = 2;
					int LA300_0 = this.input.LA(1);

					if ((LA300_0 == COMMA)) {
						this.input.LA(2);

						if ((synpred641_CSharp())) {
							alt300 = 1;
						}

					}

					switch (alt300) {
						case 1 :
						// ../rsc/CSharp.g3:2596:29: cOMMA positionalargument
							{
								pushFollow(FOLLOW_cOMMA_in_positionalargumentlist17052);
								cOMMA1199 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1199.getTree());
								pushFollow(FOLLOW_positionalargument_in_positionalargumentlist17054);
								positionalargument1200 = positionalargument();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										positionalargument1200.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "positionalargumentlist"

	public static class positionalargument_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "positionalargument"
	// ../rsc/CSharp.g3:2599:1: positionalargument : attributeargumentexpression ;
	public final CSharpParser.positionalargument_return positionalargument()
			throws RecognitionException {
		CSharpParser.positionalargument_return retval =
			new CSharpParser.positionalargument_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributeargumentexpression_return attributeargumentexpression1201 =
			null;

		try {
			// ../rsc/CSharp.g3:2600:5: ( attributeargumentexpression )
			// ../rsc/CSharp.g3:2600:9: attributeargumentexpression
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_attributeargumentexpression_in_positionalargument17075);
				attributeargumentexpression1201 = attributeargumentexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(
						root_0,
						attributeargumentexpression1201.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "positionalargument"

	public static class namedargumentlist_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "namedargumentlist"
	// ../rsc/CSharp.g3:2603:1: namedargumentlist : namedargument ( cOMMA namedargument )* ;
	public final CSharpParser.namedargumentlist_return namedargumentlist()
			throws RecognitionException {
		CSharpParser.namedargumentlist_return retval =
			new CSharpParser.namedargumentlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.namedargument_return namedargument1202 = null;

		CSharpParser.cOMMA_return cOMMA1203 = null;

		CSharpParser.namedargument_return namedargument1204 = null;

		try {
			// ../rsc/CSharp.g3:2604:5: ( namedargument ( cOMMA namedargument )* )
			// ../rsc/CSharp.g3:2604:9: namedargument ( cOMMA namedargument )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_namedargument_in_namedargumentlist17095);
				namedargument1202 = namedargument();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, namedargument1202.getTree());
				// ../rsc/CSharp.g3:2604:23: ( cOMMA namedargument )*
				loop301: do {
					int alt301 = 2;
					int LA301_0 = this.input.LA(1);

					if ((LA301_0 == COMMA)) {
						alt301 = 1;
					}

					switch (alt301) {
						case 1 :
						// ../rsc/CSharp.g3:2604:24: cOMMA namedargument
							{
								pushFollow(FOLLOW_cOMMA_in_namedargumentlist17098);
								cOMMA1203 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1203.getTree());
								pushFollow(FOLLOW_namedargument_in_namedargumentlist17100);
								namedargument1204 = namedargument();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										namedargument1204.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "namedargumentlist"

	public static class namedargument_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "namedargument"
	// ../rsc/CSharp.g3:2607:1: namedargument : identifier aSSIGN attributeargumentexpression -> ^( NamedArgument identifier aSSIGN attributeargumentexpression ) ;
	public final CSharpParser.namedargument_return namedargument()
			throws RecognitionException {
		CSharpParser.namedargument_return retval =
			new CSharpParser.namedargument_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier1205 = null;

		CSharpParser.aSSIGN_return aSSIGN1206 = null;

		CSharpParser.attributeargumentexpression_return attributeargumentexpression1207 =
			null;

		RewriteRuleSubtreeStream stream_attributeargumentexpression =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule attributeargumentexpression");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		RewriteRuleSubtreeStream stream_aSSIGN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule aSSIGN");
		try {
			// ../rsc/CSharp.g3:2608:5: ( identifier aSSIGN attributeargumentexpression -> ^( NamedArgument identifier aSSIGN attributeargumentexpression ) )
			// ../rsc/CSharp.g3:2608:9: identifier aSSIGN attributeargumentexpression
			{
				pushFollow(FOLLOW_identifier_in_namedargument17121);
				identifier1205 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1205.getTree());
				pushFollow(FOLLOW_aSSIGN_in_namedargument17123);
				aSSIGN1206 = aSSIGN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_aSSIGN.add(aSSIGN1206.getTree());
				pushFollow(FOLLOW_attributeargumentexpression_in_namedargument17125);
				attributeargumentexpression1207 = attributeargumentexpression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_attributeargumentexpression
						.add(attributeargumentexpression1207.getTree());

				// AST REWRITE
				// elements: aSSIGN, identifier, attributeargumentexpression
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2609:5: -> ^( NamedArgument identifier aSSIGN attributeargumentexpression )
					{
						// ../rsc/CSharp.g3:2609:8: ^( NamedArgument identifier aSSIGN attributeargumentexpression )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										NamedArgument,
										"NamedArgument"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());
							this.adaptor.addChild(root_1, stream_aSSIGN.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_attributeargumentexpression.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "namedargument"

	public static class attributeargumentexpression_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "attributeargumentexpression"
	// ../rsc/CSharp.g3:2612:1: attributeargumentexpression : expression ;
	public final CSharpParser.attributeargumentexpression_return attributeargumentexpression()
			throws RecognitionException {
		CSharpParser.attributeargumentexpression_return retval =
			new CSharpParser.attributeargumentexpression_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.expression_return expression1208 = null;

		try {
			// ../rsc/CSharp.g3:2613:5: ( expression )
			// ../rsc/CSharp.g3:2613:7: expression
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_expression_in_attributeargumentexpression17158);
				expression1208 = expression();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, expression1208.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "attributeargumentexpression"

	public static class typeparameterlist_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeparameterlist"
	// ../rsc/CSharp.g3:2618:1: typeparameterlist returns [String signature] : lT typeparameters gT -> ^( TypeParameterList lT typeparameters gT ) ;
	public final CSharpParser.typeparameterlist_return typeparameterlist()
			throws RecognitionException {
		CSharpParser.typeparameterlist_return retval =
			new CSharpParser.typeparameterlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lT_return lT1209 = null;

		CSharpParser.typeparameters_return typeparameters1210 = null;

		CSharpParser.gT_return gT1211 = null;

		RewriteRuleSubtreeStream stream_lT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lT");
		RewriteRuleSubtreeStream stream_typeparameters =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameters");
		RewriteRuleSubtreeStream stream_gT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gT");
		try {
			// ../rsc/CSharp.g3:2619:5: ( lT typeparameters gT -> ^( TypeParameterList lT typeparameters gT ) )
			// ../rsc/CSharp.g3:2619:9: lT typeparameters gT
			{
				pushFollow(FOLLOW_lT_in_typeparameterlist17183);
				lT1209 = lT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lT.add(lT1209.getTree());
				pushFollow(FOLLOW_typeparameters_in_typeparameterlist17185);
				typeparameters1210 = typeparameters();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_typeparameters.add(typeparameters1210.getTree());
				pushFollow(FOLLOW_gT_in_typeparameterlist17187);
				gT1211 = gT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_gT.add(gT1211.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						'<' + (typeparameters1210 != null ? typeparameters1210.signature
								: null) + '>';
				}

				// AST REWRITE
				// elements: gT, lT, typeparameters
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2621:5: -> ^( TypeParameterList lT typeparameters gT )
					{
						// ../rsc/CSharp.g3:2621:8: ^( TypeParameterList lT typeparameters gT )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										TypeParameterList,
										"TypeParameterList"), root_1);

							this.adaptor.addChild(root_1, stream_lT.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_typeparameters.nextTree());
							this.adaptor.addChild(root_1, stream_gT.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeparameterlist"

	public static class typeparameters_return extends ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeparameters"
	// ../rsc/CSharp.g3:2624:1: typeparameters returns [String signature] : t1= typeparameter_attributed ( cOMMA t2= typeparameter_attributed )* ;
	public final CSharpParser.typeparameters_return typeparameters()
			throws RecognitionException {
		CSharpParser.typeparameters_return retval =
			new CSharpParser.typeparameters_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.typeparameter_attributed_return t1 = null;

		CSharpParser.typeparameter_attributed_return t2 = null;

		CSharpParser.cOMMA_return cOMMA1212 = null;

		StringBuffer sb = new StringBuffer();

		try {
			// ../rsc/CSharp.g3:2628:5: (t1= typeparameter_attributed ( cOMMA t2= typeparameter_attributed )* )
			// ../rsc/CSharp.g3:2628:9: t1= typeparameter_attributed ( cOMMA t2= typeparameter_attributed )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_typeparameter_attributed_in_typeparameters17241);
				t1 = typeparameter_attributed();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, t1.getTree());
				if (this.state.backtracking == 0) {
					sb.append((t1 != null ? t1.signature : null));
				}
				// ../rsc/CSharp.g3:2629:6: ( cOMMA t2= typeparameter_attributed )*
				loop302: do {
					int alt302 = 2;
					int LA302_0 = this.input.LA(1);

					if ((LA302_0 == COMMA)) {
						alt302 = 1;
					}

					switch (alt302) {
						case 1 :
						// ../rsc/CSharp.g3:2629:7: cOMMA t2= typeparameter_attributed
							{
								pushFollow(FOLLOW_cOMMA_in_typeparameters17251);
								cOMMA1212 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1212.getTree());
								pushFollow(FOLLOW_typeparameter_attributed_in_typeparameters17255);
								t2 = typeparameter_attributed();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(root_0, t2.getTree());
								if (this.state.backtracking == 0) {
									sb.append(',').append(
										(t2 != null ? t2.signature : null));
								}

							}
							break;

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

				if (this.state.backtracking == 0) {
					retval.signature = sb.toString();
				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeparameters"

	public static class typeparameter_return extends ParserRuleReturnScope {
		public String name;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeparameter"
	// ../rsc/CSharp.g3:2633:1: typeparameter returns [String name] : identifier -> ^( TypeParameter identifier ) ;
	public final CSharpParser.typeparameter_return typeparameter()
			throws RecognitionException {
		CSharpParser.typeparameter_return retval =
			new CSharpParser.typeparameter_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.identifier_return identifier1213 = null;

		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:2634:5: ( identifier -> ^( TypeParameter identifier ) )
			// ../rsc/CSharp.g3:2634:9: identifier
			{
				pushFollow(FOLLOW_identifier_in_typeparameter17289);
				identifier1213 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1213.getTree());
				if (this.state.backtracking == 0) {
					retval.name =
						(identifier1213 != null ? identifier1213.content : null);
				}

				// AST REWRITE
				// elements: identifier
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2636:5: -> ^( TypeParameter identifier )
					{
						// ../rsc/CSharp.g3:2636:8: ^( TypeParameter identifier )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										TypeParameter,
										"TypeParameter"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeparameter"

	public static class typeparameter_attributed_return extends
			ParserRuleReturnScope {
		public String signature;
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeparameter_attributed"
	// ../rsc/CSharp.g3:2639:1: typeparameter_attributed returns [String signature] : ( attributes )? identifier -> ^( TypeParameter ( attributes )? identifier ) ;
	public final CSharpParser.typeparameter_attributed_return typeparameter_attributed()
			throws RecognitionException {
		CSharpParser.typeparameter_attributed_return retval =
			new CSharpParser.typeparameter_attributed_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.attributes_return attributes1214 = null;

		CSharpParser.identifier_return identifier1215 = null;

		RewriteRuleSubtreeStream stream_attributes =
			new RewriteRuleSubtreeStream(this.adaptor, "rule attributes");
		RewriteRuleSubtreeStream stream_identifier =
			new RewriteRuleSubtreeStream(this.adaptor, "rule identifier");
		try {
			// ../rsc/CSharp.g3:2643:2: ( ( attributes )? identifier -> ^( TypeParameter ( attributes )? identifier ) )
			// ../rsc/CSharp.g3:2643:4: ( attributes )? identifier
			{
				// ../rsc/CSharp.g3:2643:4: ( attributes )?
				int alt303 = 2;
				int LA303_0 = this.input.LA(1);

				if ((LA303_0 == LBRACKET)) {
					alt303 = 1;
				}
				switch (alt303) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: attributes
						{
							pushFollow(FOLLOW_attributes_in_typeparameter_attributed17328);
							attributes1214 = attributes();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_attributes.add(attributes1214.getTree());

						}
						break;

				}

				pushFollow(FOLLOW_identifier_in_typeparameter_attributed17331);
				identifier1215 = identifier();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_identifier.add(identifier1215.getTree());
				if (this.state.backtracking == 0) {
					retval.signature =
						(identifier1215 != null ? identifier1215.content : null);
				}

				// AST REWRITE
				// elements: identifier, attributes
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2645:2: -> ^( TypeParameter ( attributes )? identifier )
					{
						// ../rsc/CSharp.g3:2645:5: ^( TypeParameter ( attributes )? identifier )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										TypeParameter,
										"TypeParameter"),
									root_1);

							// ../rsc/CSharp.g3:2645:21: ( attributes )?
							if (stream_attributes.hasNext()) {
								this.adaptor.addChild(
									root_1,
									stream_attributes.nextTree());

							}
							stream_attributes.reset();
							this.adaptor.addChild(
								root_1,
								stream_identifier.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeparameter_attributed"

	public static class typeargumentlist_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeargumentlist"
	// ../rsc/CSharp.g3:2648:1: typeargumentlist : lT typearguments gT -> ^( TypeArgumentList lT typearguments gT ) ;
	public final CSharpParser.typeargumentlist_return typeargumentlist()
			throws RecognitionException {
		CSharpParser.typeargumentlist_return retval =
			new CSharpParser.typeargumentlist_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.lT_return lT1216 = null;

		CSharpParser.typearguments_return typearguments1217 = null;

		CSharpParser.gT_return gT1218 = null;

		RewriteRuleSubtreeStream stream_lT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lT");
		RewriteRuleSubtreeStream stream_typearguments =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typearguments");
		RewriteRuleSubtreeStream stream_gT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule gT");
		try {
			// ../rsc/CSharp.g3:2649:5: ( lT typearguments gT -> ^( TypeArgumentList lT typearguments gT ) )
			// ../rsc/CSharp.g3:2649:9: lT typearguments gT
			{
				pushFollow(FOLLOW_lT_in_typeargumentlist17363);
				lT1216 = lT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lT.add(lT1216.getTree());
				pushFollow(FOLLOW_typearguments_in_typeargumentlist17365);
				typearguments1217 = typearguments();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_typearguments.add(typearguments1217.getTree());
				pushFollow(FOLLOW_gT_in_typeargumentlist17367);
				gT1218 = gT();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_gT.add(gT1218.getTree());

				// AST REWRITE
				// elements: typearguments, lT, gT
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2650:5: -> ^( TypeArgumentList lT typearguments gT )
					{
						// ../rsc/CSharp.g3:2650:8: ^( TypeArgumentList lT typearguments gT )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										TypeArgumentList,
										"TypeArgumentList"), root_1);

							this.adaptor.addChild(root_1, stream_lT.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_typearguments.nextTree());
							this.adaptor.addChild(root_1, stream_gT.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeargumentlist"

	public static class typearguments_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typearguments"
	// ../rsc/CSharp.g3:2653:1: typearguments : typeargument ( cOMMA typeargument )* ;
	public final CSharpParser.typearguments_return typearguments()
			throws RecognitionException {
		CSharpParser.typearguments_return retval =
			new CSharpParser.typearguments_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.typeargument_return typeargument1219 = null;

		CSharpParser.cOMMA_return cOMMA1220 = null;

		CSharpParser.typeargument_return typeargument1221 = null;

		try {
			// ../rsc/CSharp.g3:2654:5: ( typeargument ( cOMMA typeargument )* )
			// ../rsc/CSharp.g3:2654:9: typeargument ( cOMMA typeargument )*
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_typeargument_in_typearguments17403);
				typeargument1219 = typeargument();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, typeargument1219.getTree());
				// ../rsc/CSharp.g3:2654:22: ( cOMMA typeargument )*
				loop304: do {
					int alt304 = 2;
					int LA304_0 = this.input.LA(1);

					if ((LA304_0 == COMMA)) {
						alt304 = 1;
					}

					switch (alt304) {
						case 1 :
						// ../rsc/CSharp.g3:2654:23: cOMMA typeargument
							{
								pushFollow(FOLLOW_cOMMA_in_typearguments17406);
								cOMMA1220 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1220.getTree());
								pushFollow(FOLLOW_typeargument_in_typearguments17408);
								typeargument1221 = typeargument();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										typeargument1221.getTree());

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typearguments"

	public static class typeargument_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeargument"
	// ../rsc/CSharp.g3:2657:1: typeargument : type ;
	public final CSharpParser.typeargument_return typeargument()
			throws RecognitionException {
		CSharpParser.typeargument_return retval =
			new CSharpParser.typeargument_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.type_return type1222 = null;

		try {
			// ../rsc/CSharp.g3:2658:5: ( type )
			// ../rsc/CSharp.g3:2658:9: type
			{
				root_0 = (Object) this.adaptor.nil();

				pushFollow(FOLLOW_type_in_typeargument17429);
				type1222 = type();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					this.adaptor.addChild(root_0, type1222.getTree());

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeargument"

	public static class typeparameterconstraintsclauses_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeparameterconstraintsclauses"
	// ../rsc/CSharp.g3:2661:1: typeparameterconstraintsclauses : ( typeparameterconstraintsclause )+ -> ^( TypeParameterConstraintsClauses typeparameterconstraintsclause ) ;
	public final CSharpParser.typeparameterconstraintsclauses_return typeparameterconstraintsclauses()
			throws RecognitionException {
		CSharpParser.typeparameterconstraintsclauses_return retval =
			new CSharpParser.typeparameterconstraintsclauses_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.typeparameterconstraintsclause_return typeparameterconstraintsclause1223 =
			null;

		RewriteRuleSubtreeStream stream_typeparameterconstraintsclause =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule typeparameterconstraintsclause");
		try {
			// ../rsc/CSharp.g3:2662:5: ( ( typeparameterconstraintsclause )+ -> ^( TypeParameterConstraintsClauses typeparameterconstraintsclause ) )
			// ../rsc/CSharp.g3:2662:9: ( typeparameterconstraintsclause )+
			{
				// ../rsc/CSharp.g3:2662:9: ( typeparameterconstraintsclause )+
				int cnt305 = 0;
				loop305: do {
					int alt305 = 2;
					int LA305_0 = this.input.LA(1);

					if ((LA305_0 == WHERE)) {
						alt305 = 1;
					}

					switch (alt305) {
						case 1 :
						// ../rsc/CSharp.g3:0:0: typeparameterconstraintsclause
							{
								pushFollow(FOLLOW_typeparameterconstraintsclause_in_typeparameterconstraintsclauses17449);
								typeparameterconstraintsclause1223 =
									typeparameterconstraintsclause();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									stream_typeparameterconstraintsclause
										.add(typeparameterconstraintsclause1223
											.getTree());

							}
							break;

						default :
							if (cnt305 >= 1)
								break loop305;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(305, this.input);
							throw eee;
					}
					cnt305++;
				}
				while (true);

				// AST REWRITE
				// elements: typeparameterconstraintsclause
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2663:5: -> ^( TypeParameterConstraintsClauses typeparameterconstraintsclause )
					{
						// ../rsc/CSharp.g3:2663:8: ^( TypeParameterConstraintsClauses typeparameterconstraintsclause )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										TypeParameterConstraintsClauses,
										"TypeParameterConstraintsClauses"),
									root_1);

							this.adaptor.addChild(
								root_1,
								stream_typeparameterconstraintsclause
									.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeparameterconstraintsclauses"

	public static class typeparameterconstraintsclause_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeparameterconstraintsclause"
	// ../rsc/CSharp.g3:2666:1: typeparameterconstraintsclause : wHERE typeparameter cOLON typeparameterconstraints -> ^( TypeParameterConstraintsClause wHERE typeparameter cOLON typeparameterconstraints ) ;
	public final CSharpParser.typeparameterconstraintsclause_return typeparameterconstraintsclause()
			throws RecognitionException {
		CSharpParser.typeparameterconstraintsclause_return retval =
			new CSharpParser.typeparameterconstraintsclause_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.wHERE_return wHERE1224 = null;

		CSharpParser.typeparameter_return typeparameter1225 = null;

		CSharpParser.cOLON_return cOLON1226 = null;

		CSharpParser.typeparameterconstraints_return typeparameterconstraints1227 =
			null;

		RewriteRuleSubtreeStream stream_cOLON =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOLON");
		RewriteRuleSubtreeStream stream_typeparameter =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameter");
		RewriteRuleSubtreeStream stream_typeparameterconstraints =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule typeparameterconstraints");
		RewriteRuleSubtreeStream stream_wHERE =
			new RewriteRuleSubtreeStream(this.adaptor, "rule wHERE");
		try {
			// ../rsc/CSharp.g3:2667:5: ( wHERE typeparameter cOLON typeparameterconstraints -> ^( TypeParameterConstraintsClause wHERE typeparameter cOLON typeparameterconstraints ) )
			// ../rsc/CSharp.g3:2667:9: wHERE typeparameter cOLON typeparameterconstraints
			{
				pushFollow(FOLLOW_wHERE_in_typeparameterconstraintsclause17481);
				wHERE1224 = wHERE();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_wHERE.add(wHERE1224.getTree());
				pushFollow(FOLLOW_typeparameter_in_typeparameterconstraintsclause17483);
				typeparameter1225 = typeparameter();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_typeparameter.add(typeparameter1225.getTree());
				pushFollow(FOLLOW_cOLON_in_typeparameterconstraintsclause17485);
				cOLON1226 = cOLON();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_cOLON.add(cOLON1226.getTree());
				pushFollow(FOLLOW_typeparameterconstraints_in_typeparameterconstraintsclause17487);
				typeparameterconstraints1227 = typeparameterconstraints();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_typeparameterconstraints
						.add(typeparameterconstraints1227.getTree());

				// AST REWRITE
				// elements: typeparameterconstraints, cOLON, wHERE, typeparameter
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2668:5: -> ^( TypeParameterConstraintsClause wHERE typeparameter cOLON typeparameterconstraints )
					{
						// ../rsc/CSharp.g3:2668:8: ^( TypeParameterConstraintsClause wHERE typeparameter cOLON typeparameterconstraints )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot(
									(Object) this.adaptor.create(
										TypeParameterConstraintsClause,
										"TypeParameterConstraintsClause"),
									root_1);

							this.adaptor.addChild(root_1, stream_wHERE.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_typeparameter.nextTree());
							this.adaptor.addChild(root_1, stream_cOLON.nextTree());
							this.adaptor.addChild(
								root_1,
								stream_typeparameterconstraints.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeparameterconstraintsclause"

	public static class typeparameterconstraints_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "typeparameterconstraints"
	// ../rsc/CSharp.g3:2671:1: typeparameterconstraints : ( primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint -> ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint ) | primaryconstraint cOMMA secondaryconstraints -> ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints ) | primaryconstraint cOMMA constructorconstraint -> ^( TypeParameterConstraints primaryconstraint cOMMA constructorconstraint ) | primaryconstraint -> ^( TypeParameterConstraints primaryconstraint ) | constructorconstraint -> ^( TypeParameterConstraints constructorconstraint ) );
	public final CSharpParser.typeparameterconstraints_return typeparameterconstraints()
			throws RecognitionException {
		CSharpParser.typeparameterconstraints_return retval =
			new CSharpParser.typeparameterconstraints_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.primaryconstraint_return primaryconstraint1228 = null;

		CSharpParser.cOMMA_return cOMMA1229 = null;

		CSharpParser.secondaryconstraints_return secondaryconstraints1230 =
			null;

		CSharpParser.cOMMA_return cOMMA1231 = null;

		CSharpParser.constructorconstraint_return constructorconstraint1232 =
			null;

		CSharpParser.primaryconstraint_return primaryconstraint1233 = null;

		CSharpParser.cOMMA_return cOMMA1234 = null;

		CSharpParser.secondaryconstraints_return secondaryconstraints1235 =
			null;

		CSharpParser.primaryconstraint_return primaryconstraint1236 = null;

		CSharpParser.cOMMA_return cOMMA1237 = null;

		CSharpParser.constructorconstraint_return constructorconstraint1238 =
			null;

		CSharpParser.primaryconstraint_return primaryconstraint1239 = null;

		CSharpParser.constructorconstraint_return constructorconstraint1240 =
			null;

		RewriteRuleSubtreeStream stream_primaryconstraint =
			new RewriteRuleSubtreeStream(this.adaptor, "rule primaryconstraint");
		RewriteRuleSubtreeStream stream_cOMMA =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cOMMA");
		RewriteRuleSubtreeStream stream_constructorconstraint =
			new RewriteRuleSubtreeStream(this.adaptor, "rule constructorconstraint");
		RewriteRuleSubtreeStream stream_secondaryconstraints =
			new RewriteRuleSubtreeStream(this.adaptor, "rule secondaryconstraints");
		try {
			// ../rsc/CSharp.g3:2672:5: ( primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint -> ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint ) | primaryconstraint cOMMA secondaryconstraints -> ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints ) | primaryconstraint cOMMA constructorconstraint -> ^( TypeParameterConstraints primaryconstraint cOMMA constructorconstraint ) | primaryconstraint -> ^( TypeParameterConstraints primaryconstraint ) | constructorconstraint -> ^( TypeParameterConstraints constructorconstraint ) )
			int alt306 = 5;
			alt306 = this.dfa306.predict(this.input);
			switch (alt306) {
				case 1 :
				// ../rsc/CSharp.g3:2672:9: primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint
					{
						pushFollow(FOLLOW_primaryconstraint_in_typeparameterconstraints17524);
						primaryconstraint1228 = primaryconstraint();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_primaryconstraint.add(primaryconstraint1228
								.getTree());
						pushFollow(FOLLOW_cOMMA_in_typeparameterconstraints17526);
						cOMMA1229 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA1229.getTree());
						pushFollow(FOLLOW_secondaryconstraints_in_typeparameterconstraints17528);
						secondaryconstraints1230 = secondaryconstraints();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_secondaryconstraints
								.add(secondaryconstraints1230.getTree());
						pushFollow(FOLLOW_cOMMA_in_typeparameterconstraints17530);
						cOMMA1231 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA1231.getTree());
						pushFollow(FOLLOW_constructorconstraint_in_typeparameterconstraints17532);
						constructorconstraint1232 = constructorconstraint();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constructorconstraint
								.add(constructorconstraint1232.getTree());

						// AST REWRITE
						// elements: secondaryconstraints, primaryconstraint, cOMMA, constructorconstraint, cOMMA
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2673:5: -> ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint )
							{
								// ../rsc/CSharp.g3:2673:8: ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeParameterConstraints,
												"TypeParameterConstraints"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_primaryconstraint.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_secondaryconstraints.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor
										.addChild(
											root_1,
											stream_constructorconstraint
												.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2674:9: primaryconstraint cOMMA secondaryconstraints
					{
						pushFollow(FOLLOW_primaryconstraint_in_typeparameterconstraints17562);
						primaryconstraint1233 = primaryconstraint();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_primaryconstraint.add(primaryconstraint1233
								.getTree());
						pushFollow(FOLLOW_cOMMA_in_typeparameterconstraints17564);
						cOMMA1234 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA1234.getTree());
						pushFollow(FOLLOW_secondaryconstraints_in_typeparameterconstraints17566);
						secondaryconstraints1235 = secondaryconstraints();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_secondaryconstraints
								.add(secondaryconstraints1235.getTree());

						// AST REWRITE
						// elements: secondaryconstraints, cOMMA, primaryconstraint
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2675:5: -> ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints )
							{
								// ../rsc/CSharp.g3:2675:8: ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeParameterConstraints,
												"TypeParameterConstraints"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_primaryconstraint.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_secondaryconstraints.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2676:9: primaryconstraint cOMMA constructorconstraint
					{
						pushFollow(FOLLOW_primaryconstraint_in_typeparameterconstraints17592);
						primaryconstraint1236 = primaryconstraint();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_primaryconstraint.add(primaryconstraint1236
								.getTree());
						pushFollow(FOLLOW_cOMMA_in_typeparameterconstraints17594);
						cOMMA1237 = cOMMA();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cOMMA.add(cOMMA1237.getTree());
						pushFollow(FOLLOW_constructorconstraint_in_typeparameterconstraints17596);
						constructorconstraint1238 = constructorconstraint();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constructorconstraint
								.add(constructorconstraint1238.getTree());

						// AST REWRITE
						// elements: primaryconstraint, cOMMA, constructorconstraint
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2677:5: -> ^( TypeParameterConstraints primaryconstraint cOMMA constructorconstraint )
							{
								// ../rsc/CSharp.g3:2677:8: ^( TypeParameterConstraints primaryconstraint cOMMA constructorconstraint )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeParameterConstraints,
												"TypeParameterConstraints"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_primaryconstraint.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_cOMMA.nextTree());
									this.adaptor
										.addChild(
											root_1,
											stream_constructorconstraint
												.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2680:7: primaryconstraint
					{
						pushFollow(FOLLOW_primaryconstraint_in_typeparameterconstraints17622);
						primaryconstraint1239 = primaryconstraint();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_primaryconstraint.add(primaryconstraint1239
								.getTree());

						// AST REWRITE
						// elements: primaryconstraint
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2681:5: -> ^( TypeParameterConstraints primaryconstraint )
							{
								// ../rsc/CSharp.g3:2681:8: ^( TypeParameterConstraints primaryconstraint )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeParameterConstraints,
												"TypeParameterConstraints"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_primaryconstraint.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2684:9: constructorconstraint
					{
						pushFollow(FOLLOW_constructorconstraint_in_typeparameterconstraints17646);
						constructorconstraint1240 = constructorconstraint();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_constructorconstraint
								.add(constructorconstraint1240.getTree());

						// AST REWRITE
						// elements: constructorconstraint
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2685:5: -> ^( TypeParameterConstraints constructorconstraint )
							{
								// ../rsc/CSharp.g3:2685:8: ^( TypeParameterConstraints constructorconstraint )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												TypeParameterConstraints,
												"TypeParameterConstraints"),
											root_1);

									this.adaptor
										.addChild(
											root_1,
											stream_constructorconstraint
												.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "typeparameterconstraints"

	public static class primaryconstraint_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "primaryconstraint"
	// ../rsc/CSharp.g3:2688:1: primaryconstraint : ( classtype -> ^( PrimaryConstraint classtype ) | cLASS -> ^( PrimaryConstraint cLASS ) | sTRUCT -> ^( PrimaryConstraint sTRUCT ) );
	public final CSharpParser.primaryconstraint_return primaryconstraint()
			throws RecognitionException {
		CSharpParser.primaryconstraint_return retval =
			new CSharpParser.primaryconstraint_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.classtype_return classtype1241 = null;

		CSharpParser.cLASS_return cLASS1242 = null;

		CSharpParser.sTRUCT_return sTRUCT1243 = null;

		RewriteRuleSubtreeStream stream_sTRUCT =
			new RewriteRuleSubtreeStream(this.adaptor, "rule sTRUCT");
		RewriteRuleSubtreeStream stream_classtype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule classtype");
		RewriteRuleSubtreeStream stream_cLASS =
			new RewriteRuleSubtreeStream(this.adaptor, "rule cLASS");
		try {
			// ../rsc/CSharp.g3:2689:5: ( classtype -> ^( PrimaryConstraint classtype ) | cLASS -> ^( PrimaryConstraint cLASS ) | sTRUCT -> ^( PrimaryConstraint sTRUCT ) )
			int alt307 = 3;
			switch (this.input.LA(1)) {
				case OBJECT :
				case STRING :
				case ADD :
				case ALIAS :
				case GET :
				case PARTIAL :
				case REMOVE :
				case SET :
				case WHERE :
				case YIELD :
				case Ident :
					{
						alt307 = 1;
					}
					break;
				case CLASS :
					{
						alt307 = 2;
					}
					break;
				case STRUCT :
					{
						alt307 = 3;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 307, 0, this.input);

					throw nvae;
			}

			switch (alt307) {
				case 1 :
				// ../rsc/CSharp.g3:2689:9: classtype
					{
						pushFollow(FOLLOW_classtype_in_primaryconstraint17677);
						classtype1241 = classtype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_classtype.add(classtype1241.getTree());

						// AST REWRITE
						// elements: classtype
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2690:5: -> ^( PrimaryConstraint classtype )
							{
								// ../rsc/CSharp.g3:2690:8: ^( PrimaryConstraint classtype )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												PrimaryConstraint,
												"PrimaryConstraint"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_classtype.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2691:9: cLASS
					{
						pushFollow(FOLLOW_cLASS_in_primaryconstraint17699);
						cLASS1242 = cLASS();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_cLASS.add(cLASS1242.getTree());

						// AST REWRITE
						// elements: cLASS
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2692:5: -> ^( PrimaryConstraint cLASS )
							{
								// ../rsc/CSharp.g3:2692:8: ^( PrimaryConstraint cLASS )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												PrimaryConstraint,
												"PrimaryConstraint"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_cLASS.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2693:9: sTRUCT
					{
						pushFollow(FOLLOW_sTRUCT_in_primaryconstraint17721);
						sTRUCT1243 = sTRUCT();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_sTRUCT.add(sTRUCT1243.getTree());

						// AST REWRITE
						// elements: sTRUCT
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2694:5: -> ^( PrimaryConstraint sTRUCT )
							{
								// ../rsc/CSharp.g3:2694:8: ^( PrimaryConstraint sTRUCT )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												PrimaryConstraint,
												"PrimaryConstraint"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_sTRUCT.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "primaryconstraint"

	public static class secondaryconstraints_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "secondaryconstraints"
	// ../rsc/CSharp.g3:2697:1: secondaryconstraints : ( interfacetype secondaryconstraintsrest -> ^( SecondaryConstraints interfacetype secondaryconstraintsrest ) | typeparameter secondaryconstraintsrest -> ^( SecondaryConstraints typeparameter secondaryconstraintsrest ) );
	public final CSharpParser.secondaryconstraints_return secondaryconstraints()
			throws RecognitionException {
		CSharpParser.secondaryconstraints_return retval =
			new CSharpParser.secondaryconstraints_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.interfacetype_return interfacetype1244 = null;

		CSharpParser.secondaryconstraintsrest_return secondaryconstraintsrest1245 =
			null;

		CSharpParser.typeparameter_return typeparameter1246 = null;

		CSharpParser.secondaryconstraintsrest_return secondaryconstraintsrest1247 =
			null;

		RewriteRuleSubtreeStream stream_interfacetype =
			new RewriteRuleSubtreeStream(this.adaptor, "rule interfacetype");
		RewriteRuleSubtreeStream stream_typeparameter =
			new RewriteRuleSubtreeStream(this.adaptor, "rule typeparameter");
		RewriteRuleSubtreeStream stream_secondaryconstraintsrest =
			new RewriteRuleSubtreeStream(
				this.adaptor,
				"rule secondaryconstraintsrest");
		try {
			// ../rsc/CSharp.g3:2698:5: ( interfacetype secondaryconstraintsrest -> ^( SecondaryConstraints interfacetype secondaryconstraintsrest ) | typeparameter secondaryconstraintsrest -> ^( SecondaryConstraints typeparameter secondaryconstraintsrest ) )
			int alt308 = 2;
			alt308 = this.dfa308.predict(this.input);
			switch (alt308) {
				case 1 :
				// ../rsc/CSharp.g3:2698:9: interfacetype secondaryconstraintsrest
					{
						pushFollow(FOLLOW_interfacetype_in_secondaryconstraints17752);
						interfacetype1244 = interfacetype();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_interfacetype.add(interfacetype1244
								.getTree());
						pushFollow(FOLLOW_secondaryconstraintsrest_in_secondaryconstraints17754);
						secondaryconstraintsrest1245 =
							secondaryconstraintsrest();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_secondaryconstraintsrest
								.add(secondaryconstraintsrest1245.getTree());

						// AST REWRITE
						// elements: secondaryconstraintsrest, interfacetype
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2699:5: -> ^( SecondaryConstraints interfacetype secondaryconstraintsrest )
							{
								// ../rsc/CSharp.g3:2699:8: ^( SecondaryConstraints interfacetype secondaryconstraintsrest )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												SecondaryConstraints,
												"SecondaryConstraints"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_interfacetype.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_secondaryconstraintsrest
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2700:4: typeparameter secondaryconstraintsrest
					{
						pushFollow(FOLLOW_typeparameter_in_secondaryconstraints17773);
						typeparameter1246 = typeparameter();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_typeparameter.add(typeparameter1246
								.getTree());
						pushFollow(FOLLOW_secondaryconstraintsrest_in_secondaryconstraints17775);
						secondaryconstraintsrest1247 =
							secondaryconstraintsrest();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							stream_secondaryconstraintsrest
								.add(secondaryconstraintsrest1247.getTree());

						// AST REWRITE
						// elements: secondaryconstraintsrest, typeparameter
						// token labels: 
						// rule labels: retval
						// token list labels: 
						// rule list labels: 
						// wildcard labels: 
						if (this.state.backtracking == 0) {
							retval.tree = root_0;
							new RewriteRuleSubtreeStream(
								this.adaptor,
								"rule retval",
								retval != null ? retval.tree : null);

							root_0 = (Object) this.adaptor.nil();
							// 2701:2: -> ^( SecondaryConstraints typeparameter secondaryconstraintsrest )
							{
								// ../rsc/CSharp.g3:2701:5: ^( SecondaryConstraints typeparameter secondaryconstraintsrest )
								{
									Object root_1 = (Object) this.adaptor.nil();
									root_1 =
										(Object) this.adaptor.becomeRoot(
											(Object) this.adaptor.create(
												SecondaryConstraints,
												"SecondaryConstraints"),
											root_1);

									this.adaptor.addChild(
										root_1,
										stream_typeparameter.nextTree());
									this.adaptor.addChild(
										root_1,
										stream_secondaryconstraintsrest
											.nextTree());

									this.adaptor.addChild(root_0, root_1);
								}

							}

							retval.tree = root_0;
						}
					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "secondaryconstraints"

	public static class secondaryconstraintsrest_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "secondaryconstraintsrest"
	// ../rsc/CSharp.g3:2704:1: secondaryconstraintsrest : ( cOMMA ( interfacetype | typeparameter ) )* ;
	public final CSharpParser.secondaryconstraintsrest_return secondaryconstraintsrest()
			throws RecognitionException {
		CSharpParser.secondaryconstraintsrest_return retval =
			new CSharpParser.secondaryconstraintsrest_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.cOMMA_return cOMMA1248 = null;

		CSharpParser.interfacetype_return interfacetype1249 = null;

		CSharpParser.typeparameter_return typeparameter1250 = null;

		try {
			// ../rsc/CSharp.g3:2705:2: ( ( cOMMA ( interfacetype | typeparameter ) )* )
			// ../rsc/CSharp.g3:2705:4: ( cOMMA ( interfacetype | typeparameter ) )*
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:2705:4: ( cOMMA ( interfacetype | typeparameter ) )*
				loop310: do {
					int alt310 = 2;
					alt310 = this.dfa310.predict(this.input);
					switch (alt310) {
						case 1 :
						// ../rsc/CSharp.g3:2705:5: cOMMA ( interfacetype | typeparameter )
							{
								pushFollow(FOLLOW_cOMMA_in_secondaryconstraintsrest17801);
								cOMMA1248 = cOMMA();

								this.state._fsp--;
								if (this.state.failed)
									return retval;
								if (this.state.backtracking == 0)
									this.adaptor.addChild(
										root_0,
										cOMMA1248.getTree());
								// ../rsc/CSharp.g3:2705:11: ( interfacetype | typeparameter )
								int alt309 = 2;
								alt309 = this.dfa309.predict(this.input);
								switch (alt309) {
									case 1 :
									// ../rsc/CSharp.g3:2705:12: interfacetype
										{
											pushFollow(FOLLOW_interfacetype_in_secondaryconstraintsrest17804);
											interfacetype1249 = interfacetype();

											this.state._fsp--;
											if (this.state.failed)
												return retval;
											if (this.state.backtracking == 0)
												this.adaptor
													.addChild(
														root_0,
														interfacetype1249
															.getTree());

										}
										break;
									case 2 :
									// ../rsc/CSharp.g3:2705:28: typeparameter
										{
											pushFollow(FOLLOW_typeparameter_in_secondaryconstraintsrest17808);
											typeparameter1250 = typeparameter();

											this.state._fsp--;
											if (this.state.failed)
												return retval;
											if (this.state.backtracking == 0)
												this.adaptor
													.addChild(
														root_0,
														typeparameter1250
															.getTree());

										}
										break;

								}

							}
							break;

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

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "secondaryconstraintsrest"

	public static class constructorconstraint_return extends
			ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "constructorconstraint"
	// ../rsc/CSharp.g3:2708:1: constructorconstraint : nEW lPAREN rPAREN -> ^( ConstructorConstraint nEW lPAREN rPAREN ) ;
	public final CSharpParser.constructorconstraint_return constructorconstraint()
			throws RecognitionException {
		CSharpParser.constructorconstraint_return retval =
			new CSharpParser.constructorconstraint_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.nEW_return nEW1251 = null;

		CSharpParser.lPAREN_return lPAREN1252 = null;

		CSharpParser.rPAREN_return rPAREN1253 = null;

		RewriteRuleSubtreeStream stream_lPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule lPAREN");
		RewriteRuleSubtreeStream stream_rPAREN =
			new RewriteRuleSubtreeStream(this.adaptor, "rule rPAREN");
		RewriteRuleSubtreeStream stream_nEW =
			new RewriteRuleSubtreeStream(this.adaptor, "rule nEW");
		try {
			// ../rsc/CSharp.g3:2709:5: ( nEW lPAREN rPAREN -> ^( ConstructorConstraint nEW lPAREN rPAREN ) )
			// ../rsc/CSharp.g3:2709:9: nEW lPAREN rPAREN
			{
				pushFollow(FOLLOW_nEW_in_constructorconstraint17827);
				nEW1251 = nEW();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_nEW.add(nEW1251.getTree());
				pushFollow(FOLLOW_lPAREN_in_constructorconstraint17829);
				lPAREN1252 = lPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_lPAREN.add(lPAREN1252.getTree());
				pushFollow(FOLLOW_rPAREN_in_constructorconstraint17831);
				rPAREN1253 = rPAREN();

				this.state._fsp--;
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_rPAREN.add(rPAREN1253.getTree());

				// AST REWRITE
				// elements: rPAREN, lPAREN, nEW
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2710:5: -> ^( ConstructorConstraint nEW lPAREN rPAREN )
					{
						// ../rsc/CSharp.g3:2710:8: ^( ConstructorConstraint nEW lPAREN rPAREN )
						{
							Object root_1 = (Object) this.adaptor.nil();
							root_1 =
								(Object) this.adaptor.becomeRoot((Object) this.adaptor
									.create(
										ConstructorConstraint,
										"ConstructorConstraint"), root_1);

							this.adaptor.addChild(root_1, stream_nEW.nextTree());
							this.adaptor.addChild(root_1, stream_lPAREN.nextTree());
							this.adaptor.addChild(root_1, stream_rPAREN.nextTree());

							this.adaptor.addChild(root_0, root_1);
						}

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "constructorconstraint"

	public static class literal_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "literal"
	// ../rsc/CSharp.g3:2715:1: literal : ( booleanliteral | integerliteral | realliteral | characterliteral | stringliteral | nULL );
	public final CSharpParser.literal_return literal()
			throws RecognitionException {
		CSharpParser.literal_return retval = new CSharpParser.literal_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.booleanliteral_return booleanliteral1254 = null;

		CSharpParser.integerliteral_return integerliteral1255 = null;

		CSharpParser.realliteral_return realliteral1256 = null;

		CSharpParser.characterliteral_return characterliteral1257 = null;

		CSharpParser.stringliteral_return stringliteral1258 = null;

		CSharpParser.nULL_return nULL1259 = null;

		try {
			// ../rsc/CSharp.g3:2716:5: ( booleanliteral | integerliteral | realliteral | characterliteral | stringliteral | nULL )
			int alt311 = 6;
			switch (this.input.LA(1)) {
				case FALSE :
				case TRUE :
					{
						alt311 = 1;
					}
					break;
				case Integerliteral :
					{
						alt311 = 2;
					}
					break;
				case Realliteral :
					{
						alt311 = 3;
					}
					break;
				case Characterliteral :
					{
						alt311 = 4;
					}
					break;
				case Stringliteral :
					{
						alt311 = 5;
					}
					break;
				case NULL :
					{
						alt311 = 6;
					}
					break;
				default :
					if (this.state.backtracking > 0) {
						this.state.failed = true;
						return retval;
					}
					NoViableAltException nvae =
						new NoViableAltException("", 311, 0, this.input);

					throw nvae;
			}

			switch (alt311) {
				case 1 :
				// ../rsc/CSharp.g3:2716:9: booleanliteral
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_booleanliteral_in_literal17868);
						booleanliteral1254 = booleanliteral();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								booleanliteral1254.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2717:9: integerliteral
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_integerliteral_in_literal17878);
						integerliteral1255 = integerliteral();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								integerliteral1255.getTree());

					}
					break;
				case 3 :
				// ../rsc/CSharp.g3:2718:9: realliteral
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_realliteral_in_literal17888);
						realliteral1256 = realliteral();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, realliteral1256.getTree());

					}
					break;
				case 4 :
				// ../rsc/CSharp.g3:2719:9: characterliteral
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_characterliteral_in_literal17898);
						characterliteral1257 = characterliteral();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								characterliteral1257.getTree());

					}
					break;
				case 5 :
				// ../rsc/CSharp.g3:2720:9: stringliteral
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_stringliteral_in_literal17908);
						stringliteral1258 = stringliteral();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(
								root_0,
								stringliteral1258.getTree());

					}
					break;
				case 6 :
				// ../rsc/CSharp.g3:2721:9: nULL
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_nULL_in_literal17918);
						nULL1259 = nULL();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, nULL1259.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "literal"

	public static class booleanliteral_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "booleanliteral"
	// ../rsc/CSharp.g3:2724:1: booleanliteral : ( tRUE | fALSE );
	public final CSharpParser.booleanliteral_return booleanliteral()
			throws RecognitionException {
		CSharpParser.booleanliteral_return retval =
			new CSharpParser.booleanliteral_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		CSharpParser.tRUE_return tRUE1260 = null;

		CSharpParser.fALSE_return fALSE1261 = null;

		try {
			// ../rsc/CSharp.g3:2725:5: ( tRUE | fALSE )
			int alt312 = 2;
			int LA312_0 = this.input.LA(1);

			if ((LA312_0 == TRUE)) {
				alt312 = 1;
			}
			else if ((LA312_0 == FALSE)) {
				alt312 = 2;
			}
			else {
				if (this.state.backtracking > 0) {
					this.state.failed = true;
					return retval;
				}
				NoViableAltException nvae =
					new NoViableAltException("", 312, 0, this.input);

				throw nvae;
			}
			switch (alt312) {
				case 1 :
				// ../rsc/CSharp.g3:2725:9: tRUE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_tRUE_in_booleanliteral17937);
						tRUE1260 = tRUE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, tRUE1260.getTree());

					}
					break;
				case 2 :
				// ../rsc/CSharp.g3:2726:9: fALSE
					{
						root_0 = (Object) this.adaptor.nil();

						pushFollow(FOLLOW_fALSE_in_booleanliteral17947);
						fALSE1261 = fALSE();

						this.state._fsp--;
						if (this.state.failed)
							return retval;
						if (this.state.backtracking == 0)
							this.adaptor.addChild(root_0, fALSE1261.getTree());

					}
					break;

			}
			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "booleanliteral"

	public static class ignoredtail_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "ignoredtail"
	// ../rsc/CSharp.g3:2730:1: ignoredtail options {memoize=true; } : ( Whitespace | Newline | Delimitedcomment | Singlelinecomment | Preprocessordirective )+ ;
	public final CSharpParser.ignoredtail_return ignoredtail()
			throws RecognitionException {
		CSharpParser.ignoredtail_return retval =
			new CSharpParser.ignoredtail_return();
		retval.start = this.input.LT(1);
		int ignoredtail_StartIndex = this.input.index();
		Object root_0 = null;

		Token set1262 = null;

		try {
			if (this.state.backtracking > 0 && alreadyParsedRule(this.input, 281)) {
				return retval;
			}
			// ../rsc/CSharp.g3:2735:2: ( ( Whitespace | Newline | Delimitedcomment | Singlelinecomment | Preprocessordirective )+ )
			// ../rsc/CSharp.g3:2735:4: ( Whitespace | Newline | Delimitedcomment | Singlelinecomment | Preprocessordirective )+
			{
				root_0 = (Object) this.adaptor.nil();

				// ../rsc/CSharp.g3:2735:4: ( Whitespace | Newline | Delimitedcomment | Singlelinecomment | Preprocessordirective )+
				int cnt313 = 0;
				loop313: do {
					int alt313 = 2;
					int LA313_0 = this.input.LA(1);

					if (((LA313_0 >= Whitespace && LA313_0 <= Preprocessordirective))) {
						alt313 = 1;
					}

					switch (alt313) {
						case 1 :
						// ../rsc/CSharp.g3:
							{
								set1262 = (Token) this.input.LT(1);
								if ((this.input.LA(1) >= Whitespace && this.input.LA(1) <= Preprocessordirective)) {
									this.input.consume();
									if (this.state.backtracking == 0)
										this.adaptor.addChild(
											root_0,
											(Object) this.adaptor.create(set1262));
									this.state.errorRecovery = false;
									this.state.failed = false;
								}
								else {
									if (this.state.backtracking > 0) {
										this.state.failed = true;
										return retval;
									}
									MismatchedSetException mse =
										new MismatchedSetException(null, this.input);
									throw mse;
								}

							}
							break;

						default :
							if (cnt313 >= 1)
								break loop313;
							if (this.state.backtracking > 0) {
								this.state.failed = true;
								return retval;
							}
							EarlyExitException eee =
								new EarlyExitException(313, this.input);
							throw eee;
					}
					cnt313++;
				}
				while (true);

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
			if (this.state.backtracking > 0) {
				memoize(this.input, 281, ignoredtail_StartIndex);
			}
		}
		return retval;
	}
	// $ANTLR end "ignoredtail"

	public static class lBRACE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lBRACE"
	// ../rsc/CSharp.g3:2743:1: lBRACE : LBRACE ( ignoredtail )? ;
	public final CSharpParser.lBRACE_return lBRACE()
			throws RecognitionException {
		CSharpParser.lBRACE_return retval = new CSharpParser.lBRACE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LBRACE1263 = null;
		Object LBRACE1263_tree = null;

		try {
			// ../rsc/CSharp.g3:2743:21: ( LBRACE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2743:23: LBRACE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LBRACE1263 =
					(Token) match(this.input, LBRACE, FOLLOW_LBRACE_in_lBRACE18021);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LBRACE1263_tree = (Object) this.adaptor.create(LBRACE1263);
					this.adaptor.addChild(root_0, LBRACE1263_tree);
				}
				// ../rsc/CSharp.g3:2743:30: ( ignoredtail )?
				int alt314 = 2;
				int LA314_0 = this.input.LA(1);

				if (((LA314_0 >= Whitespace && LA314_0 <= Preprocessordirective))) {
					alt314 = 1;
				}
				switch (alt314) {
					case 1 :
					// ../rsc/CSharp.g3:2743:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lBRACE18024);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lBRACE"

	public static class rBRACE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rBRACE"
	// ../rsc/CSharp.g3:2744:1: rBRACE : RBRACE ( ignoredtail )? ;
	public final CSharpParser.rBRACE_return rBRACE()
			throws RecognitionException {
		CSharpParser.rBRACE_return retval = new CSharpParser.rBRACE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token RBRACE1265 = null;
		Object RBRACE1265_tree = null;

		try {
			// ../rsc/CSharp.g3:2744:21: ( RBRACE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2744:23: RBRACE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				RBRACE1265 =
					(Token) match(this.input, RBRACE, FOLLOW_RBRACE_in_rBRACE18047);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					RBRACE1265_tree = (Object) this.adaptor.create(RBRACE1265);
					this.adaptor.addChild(root_0, RBRACE1265_tree);
				}
				// ../rsc/CSharp.g3:2744:30: ( ignoredtail )?
				int alt315 = 2;
				int LA315_0 = this.input.LA(1);

				if (((LA315_0 >= Whitespace && LA315_0 <= Preprocessordirective))) {
					alt315 = 1;
				}
				switch (alt315) {
					case 1 :
					// ../rsc/CSharp.g3:2744:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rBRACE18050);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rBRACE"

	public static class lBRACKET_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lBRACKET"
	// ../rsc/CSharp.g3:2745:1: lBRACKET : LBRACKET ( ignoredtail )? ;
	public final CSharpParser.lBRACKET_return lBRACKET()
			throws RecognitionException {
		CSharpParser.lBRACKET_return retval =
			new CSharpParser.lBRACKET_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LBRACKET1267 = null;
		Object LBRACKET1267_tree = null;

		try {
			// ../rsc/CSharp.g3:2745:21: ( LBRACKET ( ignoredtail )? )
			// ../rsc/CSharp.g3:2745:23: LBRACKET ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LBRACKET1267 =
					(Token) match(
						this.input,
						LBRACKET,
						FOLLOW_LBRACKET_in_lBRACKET18071);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LBRACKET1267_tree = (Object) this.adaptor.create(LBRACKET1267);
					this.adaptor.addChild(root_0, LBRACKET1267_tree);
				}
				// ../rsc/CSharp.g3:2745:32: ( ignoredtail )?
				int alt316 = 2;
				int LA316_0 = this.input.LA(1);

				if (((LA316_0 >= Whitespace && LA316_0 <= Preprocessordirective))) {
					alt316 = 1;
				}
				switch (alt316) {
					case 1 :
					// ../rsc/CSharp.g3:2745:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lBRACKET18074);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lBRACKET"

	public static class rBRACKET_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rBRACKET"
	// ../rsc/CSharp.g3:2746:1: rBRACKET : RBRACKET ( ignoredtail )? ;
	public final CSharpParser.rBRACKET_return rBRACKET()
			throws RecognitionException {
		CSharpParser.rBRACKET_return retval =
			new CSharpParser.rBRACKET_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token RBRACKET1269 = null;
		Object RBRACKET1269_tree = null;

		try {
			// ../rsc/CSharp.g3:2746:21: ( RBRACKET ( ignoredtail )? )
			// ../rsc/CSharp.g3:2746:23: RBRACKET ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				RBRACKET1269 =
					(Token) match(
						this.input,
						RBRACKET,
						FOLLOW_RBRACKET_in_rBRACKET18095);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					RBRACKET1269_tree = (Object) this.adaptor.create(RBRACKET1269);
					this.adaptor.addChild(root_0, RBRACKET1269_tree);
				}
				// ../rsc/CSharp.g3:2746:32: ( ignoredtail )?
				int alt317 = 2;
				int LA317_0 = this.input.LA(1);

				if (((LA317_0 >= Whitespace && LA317_0 <= Preprocessordirective))) {
					alt317 = 1;
				}
				switch (alt317) {
					case 1 :
					// ../rsc/CSharp.g3:2746:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rBRACKET18098);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rBRACKET"

	public static class lPAREN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lPAREN"
	// ../rsc/CSharp.g3:2747:1: lPAREN : LPAREN ( ignoredtail )? ;
	public final CSharpParser.lPAREN_return lPAREN()
			throws RecognitionException {
		CSharpParser.lPAREN_return retval = new CSharpParser.lPAREN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LPAREN1271 = null;
		Object LPAREN1271_tree = null;

		try {
			// ../rsc/CSharp.g3:2747:21: ( LPAREN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2747:23: LPAREN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LPAREN1271 =
					(Token) match(this.input, LPAREN, FOLLOW_LPAREN_in_lPAREN18121);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LPAREN1271_tree = (Object) this.adaptor.create(LPAREN1271);
					this.adaptor.addChild(root_0, LPAREN1271_tree);
				}
				// ../rsc/CSharp.g3:2747:30: ( ignoredtail )?
				int alt318 = 2;
				int LA318_0 = this.input.LA(1);

				if (((LA318_0 >= Whitespace && LA318_0 <= Preprocessordirective))) {
					alt318 = 1;
				}
				switch (alt318) {
					case 1 :
					// ../rsc/CSharp.g3:2747:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lPAREN18124);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lPAREN"

	public static class rPAREN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rPAREN"
	// ../rsc/CSharp.g3:2748:1: rPAREN : RPAREN ( ignoredtail )? ;
	public final CSharpParser.rPAREN_return rPAREN()
			throws RecognitionException {
		CSharpParser.rPAREN_return retval = new CSharpParser.rPAREN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token RPAREN1273 = null;
		Object RPAREN1273_tree = null;

		try {
			// ../rsc/CSharp.g3:2748:21: ( RPAREN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2748:23: RPAREN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				RPAREN1273 =
					(Token) match(this.input, RPAREN, FOLLOW_RPAREN_in_rPAREN18147);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					RPAREN1273_tree = (Object) this.adaptor.create(RPAREN1273);
					this.adaptor.addChild(root_0, RPAREN1273_tree);
				}
				// ../rsc/CSharp.g3:2748:30: ( ignoredtail )?
				int alt319 = 2;
				int LA319_0 = this.input.LA(1);

				if (((LA319_0 >= Whitespace && LA319_0 <= Preprocessordirective))) {
					alt319 = 1;
				}
				switch (alt319) {
					case 1 :
					// ../rsc/CSharp.g3:2748:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rPAREN18150);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rPAREN"

	public static class dOT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dOT"
	// ../rsc/CSharp.g3:2749:1: dOT : DOT ( ignoredtail )? ;
	public final CSharpParser.dOT_return dOT() throws RecognitionException {
		CSharpParser.dOT_return retval = new CSharpParser.dOT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DOT1275 = null;
		Object DOT1275_tree = null;

		try {
			// ../rsc/CSharp.g3:2749:21: ( DOT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2749:23: DOT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DOT1275 = (Token) match(this.input, DOT, FOLLOW_DOT_in_dOT18176);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DOT1275_tree = (Object) this.adaptor.create(DOT1275);
					this.adaptor.addChild(root_0, DOT1275_tree);
				}
				// ../rsc/CSharp.g3:2749:27: ( ignoredtail )?
				int alt320 = 2;
				int LA320_0 = this.input.LA(1);

				if (((LA320_0 >= Whitespace && LA320_0 <= Preprocessordirective))) {
					alt320 = 1;
				}
				switch (alt320) {
					case 1 :
					// ../rsc/CSharp.g3:2749:28: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dOT18179);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dOT"

	public static class cOMMA_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cOMMA"
	// ../rsc/CSharp.g3:2750:1: cOMMA : COMMA ( ignoredtail )? ;
	public final CSharpParser.cOMMA_return cOMMA() throws RecognitionException {
		CSharpParser.cOMMA_return retval = new CSharpParser.cOMMA_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token COMMA1277 = null;
		Object COMMA1277_tree = null;

		try {
			// ../rsc/CSharp.g3:2750:21: ( COMMA ( ignoredtail )? )
			// ../rsc/CSharp.g3:2750:23: COMMA ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				COMMA1277 =
					(Token) match(this.input, COMMA, FOLLOW_COMMA_in_cOMMA18203);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					COMMA1277_tree = (Object) this.adaptor.create(COMMA1277);
					this.adaptor.addChild(root_0, COMMA1277_tree);
				}
				// ../rsc/CSharp.g3:2750:29: ( ignoredtail )?
				int alt321 = 2;
				int LA321_0 = this.input.LA(1);

				if (((LA321_0 >= Whitespace && LA321_0 <= Preprocessordirective))) {
					alt321 = 1;
				}
				switch (alt321) {
					case 1 :
					// ../rsc/CSharp.g3:2750:30: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cOMMA18206);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cOMMA"

	public static class cOLON_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cOLON"
	// ../rsc/CSharp.g3:2751:1: cOLON : COLON ( ignoredtail )? ;
	public final CSharpParser.cOLON_return cOLON() throws RecognitionException {
		CSharpParser.cOLON_return retval = new CSharpParser.cOLON_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token COLON1279 = null;
		Object COLON1279_tree = null;

		try {
			// ../rsc/CSharp.g3:2751:21: ( COLON ( ignoredtail )? )
			// ../rsc/CSharp.g3:2751:23: COLON ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				COLON1279 =
					(Token) match(this.input, COLON, FOLLOW_COLON_in_cOLON18230);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					COLON1279_tree = (Object) this.adaptor.create(COLON1279);
					this.adaptor.addChild(root_0, COLON1279_tree);
				}
				// ../rsc/CSharp.g3:2751:29: ( ignoredtail )?
				int alt322 = 2;
				int LA322_0 = this.input.LA(1);

				if (((LA322_0 >= Whitespace && LA322_0 <= Preprocessordirective))) {
					alt322 = 1;
				}
				switch (alt322) {
					case 1 :
					// ../rsc/CSharp.g3:2751:30: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cOLON18233);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cOLON"

	public static class sEMICOLON_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sEMICOLON"
	// ../rsc/CSharp.g3:2752:1: sEMICOLON : SEMICOLON ( ignoredtail )? ;
	public final CSharpParser.sEMICOLON_return sEMICOLON()
			throws RecognitionException {
		CSharpParser.sEMICOLON_return retval =
			new CSharpParser.sEMICOLON_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token SEMICOLON1281 = null;
		Object SEMICOLON1281_tree = null;

		try {
			// ../rsc/CSharp.g3:2752:21: ( SEMICOLON ( ignoredtail )? )
			// ../rsc/CSharp.g3:2752:23: SEMICOLON ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				SEMICOLON1281 =
					(Token) match(
						this.input,
						SEMICOLON,
						FOLLOW_SEMICOLON_in_sEMICOLON18253);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					SEMICOLON1281_tree = (Object) this.adaptor.create(SEMICOLON1281);
					this.adaptor.addChild(root_0, SEMICOLON1281_tree);
				}
				// ../rsc/CSharp.g3:2752:33: ( ignoredtail )?
				int alt323 = 2;
				int LA323_0 = this.input.LA(1);

				if (((LA323_0 >= Whitespace && LA323_0 <= Preprocessordirective))) {
					alt323 = 1;
				}
				switch (alt323) {
					case 1 :
					// ../rsc/CSharp.g3:2752:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sEMICOLON18256);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sEMICOLON"

	public static class pLUS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "pLUS"
	// ../rsc/CSharp.g3:2753:1: pLUS : PLUS ( ignoredtail )? ;
	public final CSharpParser.pLUS_return pLUS() throws RecognitionException {
		CSharpParser.pLUS_return retval = new CSharpParser.pLUS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token PLUS1283 = null;
		Object PLUS1283_tree = null;

		try {
			// ../rsc/CSharp.g3:2753:21: ( PLUS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2753:23: PLUS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				PLUS1283 = (Token) match(this.input, PLUS, FOLLOW_PLUS_in_pLUS18281);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					PLUS1283_tree = (Object) this.adaptor.create(PLUS1283);
					this.adaptor.addChild(root_0, PLUS1283_tree);
				}
				// ../rsc/CSharp.g3:2753:28: ( ignoredtail )?
				int alt324 = 2;
				int LA324_0 = this.input.LA(1);

				if (((LA324_0 >= Whitespace && LA324_0 <= Preprocessordirective))) {
					alt324 = 1;
				}
				switch (alt324) {
					case 1 :
					// ../rsc/CSharp.g3:2753:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_pLUS18284);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "pLUS"

	public static class mINUS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "mINUS"
	// ../rsc/CSharp.g3:2754:1: mINUS : MINUS ( ignoredtail )? ;
	public final CSharpParser.mINUS_return mINUS() throws RecognitionException {
		CSharpParser.mINUS_return retval = new CSharpParser.mINUS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token MINUS1285 = null;
		Object MINUS1285_tree = null;

		try {
			// ../rsc/CSharp.g3:2754:21: ( MINUS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2754:23: MINUS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				MINUS1285 =
					(Token) match(this.input, MINUS, FOLLOW_MINUS_in_mINUS18308);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					MINUS1285_tree = (Object) this.adaptor.create(MINUS1285);
					this.adaptor.addChild(root_0, MINUS1285_tree);
				}
				// ../rsc/CSharp.g3:2754:29: ( ignoredtail )?
				int alt325 = 2;
				int LA325_0 = this.input.LA(1);

				if (((LA325_0 >= Whitespace && LA325_0 <= Preprocessordirective))) {
					alt325 = 1;
				}
				switch (alt325) {
					case 1 :
					// ../rsc/CSharp.g3:2754:30: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_mINUS18311);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "mINUS"

	public static class mUL_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "mUL"
	// ../rsc/CSharp.g3:2755:1: mUL : MUL ( ignoredtail )? ;
	public final CSharpParser.mUL_return mUL() throws RecognitionException {
		CSharpParser.mUL_return retval = new CSharpParser.mUL_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token MUL1287 = null;
		Object MUL1287_tree = null;

		try {
			// ../rsc/CSharp.g3:2755:21: ( MUL ( ignoredtail )? )
			// ../rsc/CSharp.g3:2755:23: MUL ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				MUL1287 = (Token) match(this.input, MUL, FOLLOW_MUL_in_mUL18337);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					MUL1287_tree = (Object) this.adaptor.create(MUL1287);
					this.adaptor.addChild(root_0, MUL1287_tree);
				}
				// ../rsc/CSharp.g3:2755:27: ( ignoredtail )?
				int alt326 = 2;
				int LA326_0 = this.input.LA(1);

				if (((LA326_0 >= Whitespace && LA326_0 <= Preprocessordirective))) {
					alt326 = 1;
				}
				switch (alt326) {
					case 1 :
					// ../rsc/CSharp.g3:2755:28: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_mUL18340);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "mUL"

	public static class dIV_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dIV"
	// ../rsc/CSharp.g3:2756:1: dIV : DIV ( ignoredtail )? ;
	public final CSharpParser.dIV_return dIV() throws RecognitionException {
		CSharpParser.dIV_return retval = new CSharpParser.dIV_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DIV1289 = null;
		Object DIV1289_tree = null;

		try {
			// ../rsc/CSharp.g3:2756:21: ( DIV ( ignoredtail )? )
			// ../rsc/CSharp.g3:2756:23: DIV ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DIV1289 = (Token) match(this.input, DIV, FOLLOW_DIV_in_dIV18366);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DIV1289_tree = (Object) this.adaptor.create(DIV1289);
					this.adaptor.addChild(root_0, DIV1289_tree);
				}
				// ../rsc/CSharp.g3:2756:27: ( ignoredtail )?
				int alt327 = 2;
				int LA327_0 = this.input.LA(1);

				if (((LA327_0 >= Whitespace && LA327_0 <= Preprocessordirective))) {
					alt327 = 1;
				}
				switch (alt327) {
					case 1 :
					// ../rsc/CSharp.g3:2756:28: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dIV18369);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dIV"

	public static class mOD_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "mOD"
	// ../rsc/CSharp.g3:2757:1: mOD : MOD ( ignoredtail )? ;
	public final CSharpParser.mOD_return mOD() throws RecognitionException {
		CSharpParser.mOD_return retval = new CSharpParser.mOD_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token MOD1291 = null;
		Object MOD1291_tree = null;

		try {
			// ../rsc/CSharp.g3:2757:21: ( MOD ( ignoredtail )? )
			// ../rsc/CSharp.g3:2757:23: MOD ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				MOD1291 = (Token) match(this.input, MOD, FOLLOW_MOD_in_mOD18395);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					MOD1291_tree = (Object) this.adaptor.create(MOD1291);
					this.adaptor.addChild(root_0, MOD1291_tree);
				}
				// ../rsc/CSharp.g3:2757:27: ( ignoredtail )?
				int alt328 = 2;
				int LA328_0 = this.input.LA(1);

				if (((LA328_0 >= Whitespace && LA328_0 <= Preprocessordirective))) {
					alt328 = 1;
				}
				switch (alt328) {
					case 1 :
					// ../rsc/CSharp.g3:2757:28: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_mOD18398);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "mOD"

	public static class aMPERSAND_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "aMPERSAND"
	// ../rsc/CSharp.g3:2758:1: aMPERSAND : AMPERSAND ( ignoredtail )? ;
	public final CSharpParser.aMPERSAND_return aMPERSAND()
			throws RecognitionException {
		CSharpParser.aMPERSAND_return retval =
			new CSharpParser.aMPERSAND_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token AMPERSAND1293 = null;
		Object AMPERSAND1293_tree = null;

		try {
			// ../rsc/CSharp.g3:2758:21: ( AMPERSAND ( ignoredtail )? )
			// ../rsc/CSharp.g3:2758:23: AMPERSAND ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				AMPERSAND1293 =
					(Token) match(
						this.input,
						AMPERSAND,
						FOLLOW_AMPERSAND_in_aMPERSAND18418);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					AMPERSAND1293_tree = (Object) this.adaptor.create(AMPERSAND1293);
					this.adaptor.addChild(root_0, AMPERSAND1293_tree);
				}
				// ../rsc/CSharp.g3:2758:33: ( ignoredtail )?
				int alt329 = 2;
				int LA329_0 = this.input.LA(1);

				if (((LA329_0 >= Whitespace && LA329_0 <= Preprocessordirective))) {
					alt329 = 1;
				}
				switch (alt329) {
					case 1 :
					// ../rsc/CSharp.g3:2758:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_aMPERSAND18421);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "aMPERSAND"

	public static class bITWISEOR_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bITWISEOR"
	// ../rsc/CSharp.g3:2759:1: bITWISEOR : BITWISEOR ( ignoredtail )? ;
	public final CSharpParser.bITWISEOR_return bITWISEOR()
			throws RecognitionException {
		CSharpParser.bITWISEOR_return retval =
			new CSharpParser.bITWISEOR_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BITWISEOR1295 = null;
		Object BITWISEOR1295_tree = null;

		try {
			// ../rsc/CSharp.g3:2759:21: ( BITWISEOR ( ignoredtail )? )
			// ../rsc/CSharp.g3:2759:23: BITWISEOR ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BITWISEOR1295 =
					(Token) match(
						this.input,
						BITWISEOR,
						FOLLOW_BITWISEOR_in_bITWISEOR18441);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BITWISEOR1295_tree = (Object) this.adaptor.create(BITWISEOR1295);
					this.adaptor.addChild(root_0, BITWISEOR1295_tree);
				}
				// ../rsc/CSharp.g3:2759:33: ( ignoredtail )?
				int alt330 = 2;
				int LA330_0 = this.input.LA(1);

				if (((LA330_0 >= Whitespace && LA330_0 <= Preprocessordirective))) {
					alt330 = 1;
				}
				switch (alt330) {
					case 1 :
					// ../rsc/CSharp.g3:2759:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bITWISEOR18444);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bITWISEOR"

	public static class bITWISEXOR_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bITWISEXOR"
	// ../rsc/CSharp.g3:2760:1: bITWISEXOR : BITWISEXOR ( ignoredtail )? ;
	public final CSharpParser.bITWISEXOR_return bITWISEXOR()
			throws RecognitionException {
		CSharpParser.bITWISEXOR_return retval =
			new CSharpParser.bITWISEXOR_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BITWISEXOR1297 = null;
		Object BITWISEXOR1297_tree = null;

		try {
			// ../rsc/CSharp.g3:2760:21: ( BITWISEXOR ( ignoredtail )? )
			// ../rsc/CSharp.g3:2760:23: BITWISEXOR ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BITWISEXOR1297 =
					(Token) match(
						this.input,
						BITWISEXOR,
						FOLLOW_BITWISEXOR_in_bITWISEXOR18463);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BITWISEXOR1297_tree =
						(Object) this.adaptor.create(BITWISEXOR1297);
					this.adaptor.addChild(root_0, BITWISEXOR1297_tree);
				}
				// ../rsc/CSharp.g3:2760:34: ( ignoredtail )?
				int alt331 = 2;
				int LA331_0 = this.input.LA(1);

				if (((LA331_0 >= Whitespace && LA331_0 <= Preprocessordirective))) {
					alt331 = 1;
				}
				switch (alt331) {
					case 1 :
					// ../rsc/CSharp.g3:2760:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bITWISEXOR18466);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bITWISEXOR"

	public static class eXCLAM_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eXCLAM"
	// ../rsc/CSharp.g3:2761:1: eXCLAM : EXCLAM ( ignoredtail )? ;
	public final CSharpParser.eXCLAM_return eXCLAM()
			throws RecognitionException {
		CSharpParser.eXCLAM_return retval = new CSharpParser.eXCLAM_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token EXCLAM1299 = null;
		Object EXCLAM1299_tree = null;

		try {
			// ../rsc/CSharp.g3:2761:21: ( EXCLAM ( ignoredtail )? )
			// ../rsc/CSharp.g3:2761:23: EXCLAM ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				EXCLAM1299 =
					(Token) match(this.input, EXCLAM, FOLLOW_EXCLAM_in_eXCLAM18489);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					EXCLAM1299_tree = (Object) this.adaptor.create(EXCLAM1299);
					this.adaptor.addChild(root_0, EXCLAM1299_tree);
				}
				// ../rsc/CSharp.g3:2761:30: ( ignoredtail )?
				int alt332 = 2;
				int LA332_0 = this.input.LA(1);

				if (((LA332_0 >= Whitespace && LA332_0 <= Preprocessordirective))) {
					alt332 = 1;
				}
				switch (alt332) {
					case 1 :
					// ../rsc/CSharp.g3:2761:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_eXCLAM18492);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eXCLAM"

	public static class tILDE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "tILDE"
	// ../rsc/CSharp.g3:2762:1: tILDE : TILDE ( ignoredtail )? ;
	public final CSharpParser.tILDE_return tILDE() throws RecognitionException {
		CSharpParser.tILDE_return retval = new CSharpParser.tILDE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token TILDE1301 = null;
		Object TILDE1301_tree = null;

		try {
			// ../rsc/CSharp.g3:2762:21: ( TILDE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2762:23: TILDE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				TILDE1301 =
					(Token) match(this.input, TILDE, FOLLOW_TILDE_in_tILDE18516);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					TILDE1301_tree = (Object) this.adaptor.create(TILDE1301);
					this.adaptor.addChild(root_0, TILDE1301_tree);
				}
				// ../rsc/CSharp.g3:2762:29: ( ignoredtail )?
				int alt333 = 2;
				int LA333_0 = this.input.LA(1);

				if (((LA333_0 >= Whitespace && LA333_0 <= Preprocessordirective))) {
					alt333 = 1;
				}
				switch (alt333) {
					case 1 :
					// ../rsc/CSharp.g3:2762:30: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_tILDE18519);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "tILDE"

	public static class aSSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "aSSIGN"
	// ../rsc/CSharp.g3:2763:1: aSSIGN : ASSIGN ( ignoredtail )? ;
	public final CSharpParser.aSSIGN_return aSSIGN()
			throws RecognitionException {
		CSharpParser.aSSIGN_return retval = new CSharpParser.aSSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ASSIGN1303 = null;
		Object ASSIGN1303_tree = null;

		try {
			// ../rsc/CSharp.g3:2763:21: ( ASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2763:23: ASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ASSIGN1303 =
					(Token) match(this.input, ASSIGN, FOLLOW_ASSIGN_in_aSSIGN18542);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ASSIGN1303_tree = (Object) this.adaptor.create(ASSIGN1303);
					this.adaptor.addChild(root_0, ASSIGN1303_tree);
				}
				// ../rsc/CSharp.g3:2763:30: ( ignoredtail )?
				int alt334 = 2;
				int LA334_0 = this.input.LA(1);

				if (((LA334_0 >= Whitespace && LA334_0 <= Preprocessordirective))) {
					alt334 = 1;
				}
				switch (alt334) {
					case 1 :
					// ../rsc/CSharp.g3:2763:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_aSSIGN18545);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "aSSIGN"

	public static class lT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lT"
	// ../rsc/CSharp.g3:2764:1: lT : LT ( ignoredtail )? ;
	public final CSharpParser.lT_return lT() throws RecognitionException {
		CSharpParser.lT_return retval = new CSharpParser.lT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LT1305 = null;
		Object LT1305_tree = null;

		try {
			// ../rsc/CSharp.g3:2764:21: ( LT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2764:23: LT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LT1305 = (Token) match(this.input, LT, FOLLOW_LT_in_lT18572);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LT1305_tree = (Object) this.adaptor.create(LT1305);
					this.adaptor.addChild(root_0, LT1305_tree);
				}
				// ../rsc/CSharp.g3:2764:26: ( ignoredtail )?
				int alt335 = 2;
				int LA335_0 = this.input.LA(1);

				if (((LA335_0 >= Whitespace && LA335_0 <= Preprocessordirective))) {
					alt335 = 1;
				}
				switch (alt335) {
					case 1 :
					// ../rsc/CSharp.g3:2764:27: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lT18575);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lT"

	public static class qUESTION_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "qUESTION"
	// ../rsc/CSharp.g3:2765:1: qUESTION : QUESTION ( ignoredtail )? ;
	public final CSharpParser.qUESTION_return qUESTION()
			throws RecognitionException {
		CSharpParser.qUESTION_return retval =
			new CSharpParser.qUESTION_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token QUESTION1307 = null;
		Object QUESTION1307_tree = null;

		try {
			// ../rsc/CSharp.g3:2765:21: ( QUESTION ( ignoredtail )? )
			// ../rsc/CSharp.g3:2765:23: QUESTION ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				QUESTION1307 =
					(Token) match(
						this.input,
						QUESTION,
						FOLLOW_QUESTION_in_qUESTION18596);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					QUESTION1307_tree = (Object) this.adaptor.create(QUESTION1307);
					this.adaptor.addChild(root_0, QUESTION1307_tree);
				}
				// ../rsc/CSharp.g3:2765:32: ( ignoredtail )?
				int alt336 = 2;
				int LA336_0 = this.input.LA(1);

				if (((LA336_0 >= Whitespace && LA336_0 <= Preprocessordirective))) {
					alt336 = 1;
				}
				switch (alt336) {
					case 1 :
					// ../rsc/CSharp.g3:2765:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_qUESTION18599);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "qUESTION"

	public static class dOUBLEQUESTION_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dOUBLEQUESTION"
	// ../rsc/CSharp.g3:2766:1: dOUBLEQUESTION : DOUBLEQUESTION ( ignoredtail )? ;
	public final CSharpParser.dOUBLEQUESTION_return dOUBLEQUESTION()
			throws RecognitionException {
		CSharpParser.dOUBLEQUESTION_return retval =
			new CSharpParser.dOUBLEQUESTION_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DOUBLEQUESTION1309 = null;
		Object DOUBLEQUESTION1309_tree = null;

		try {
			// ../rsc/CSharp.g3:2766:21: ( DOUBLEQUESTION ( ignoredtail )? )
			// ../rsc/CSharp.g3:2766:23: DOUBLEQUESTION ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DOUBLEQUESTION1309 =
					(Token) match(
						this.input,
						DOUBLEQUESTION,
						FOLLOW_DOUBLEQUESTION_in_dOUBLEQUESTION18614);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DOUBLEQUESTION1309_tree =
						(Object) this.adaptor.create(DOUBLEQUESTION1309);
					this.adaptor.addChild(root_0, DOUBLEQUESTION1309_tree);
				}
				// ../rsc/CSharp.g3:2766:38: ( ignoredtail )?
				int alt337 = 2;
				int LA337_0 = this.input.LA(1);

				if (((LA337_0 >= Whitespace && LA337_0 <= Preprocessordirective))) {
					alt337 = 1;
				}
				switch (alt337) {
					case 1 :
					// ../rsc/CSharp.g3:2766:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dOUBLEQUESTION18617);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dOUBLEQUESTION"

	public static class dOUBLECOLON_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dOUBLECOLON"
	// ../rsc/CSharp.g3:2767:1: dOUBLECOLON : DOUBLECOLON ( ignoredtail )? ;
	public final CSharpParser.dOUBLECOLON_return dOUBLECOLON()
			throws RecognitionException {
		CSharpParser.dOUBLECOLON_return retval =
			new CSharpParser.dOUBLECOLON_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DOUBLECOLON1311 = null;
		Object DOUBLECOLON1311_tree = null;

		try {
			// ../rsc/CSharp.g3:2767:21: ( DOUBLECOLON ( ignoredtail )? )
			// ../rsc/CSharp.g3:2767:23: DOUBLECOLON ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DOUBLECOLON1311 =
					(Token) match(
						this.input,
						DOUBLECOLON,
						FOLLOW_DOUBLECOLON_in_dOUBLECOLON18635);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DOUBLECOLON1311_tree =
						(Object) this.adaptor.create(DOUBLECOLON1311);
					this.adaptor.addChild(root_0, DOUBLECOLON1311_tree);
				}
				// ../rsc/CSharp.g3:2767:35: ( ignoredtail )?
				int alt338 = 2;
				int LA338_0 = this.input.LA(1);

				if (((LA338_0 >= Whitespace && LA338_0 <= Preprocessordirective))) {
					alt338 = 1;
				}
				switch (alt338) {
					case 1 :
					// ../rsc/CSharp.g3:2767:36: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dOUBLECOLON18638);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dOUBLECOLON"

	public static class iNCREMENT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iNCREMENT"
	// ../rsc/CSharp.g3:2768:1: iNCREMENT : INCREMENT ( ignoredtail )? ;
	public final CSharpParser.iNCREMENT_return iNCREMENT()
			throws RecognitionException {
		CSharpParser.iNCREMENT_return retval =
			new CSharpParser.iNCREMENT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token INCREMENT1313 = null;
		Object INCREMENT1313_tree = null;

		try {
			// ../rsc/CSharp.g3:2768:21: ( INCREMENT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2768:23: INCREMENT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				INCREMENT1313 =
					(Token) match(
						this.input,
						INCREMENT,
						FOLLOW_INCREMENT_in_iNCREMENT18658);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					INCREMENT1313_tree = (Object) this.adaptor.create(INCREMENT1313);
					this.adaptor.addChild(root_0, INCREMENT1313_tree);
				}
				// ../rsc/CSharp.g3:2768:33: ( ignoredtail )?
				int alt339 = 2;
				int LA339_0 = this.input.LA(1);

				if (((LA339_0 >= Whitespace && LA339_0 <= Preprocessordirective))) {
					alt339 = 1;
				}
				switch (alt339) {
					case 1 :
					// ../rsc/CSharp.g3:2768:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_iNCREMENT18661);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iNCREMENT"

	public static class dECREMENT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dECREMENT"
	// ../rsc/CSharp.g3:2769:1: dECREMENT : DECREMENT ( ignoredtail )? ;
	public final CSharpParser.dECREMENT_return dECREMENT()
			throws RecognitionException {
		CSharpParser.dECREMENT_return retval =
			new CSharpParser.dECREMENT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DECREMENT1315 = null;
		Object DECREMENT1315_tree = null;

		try {
			// ../rsc/CSharp.g3:2769:21: ( DECREMENT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2769:23: DECREMENT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DECREMENT1315 =
					(Token) match(
						this.input,
						DECREMENT,
						FOLLOW_DECREMENT_in_dECREMENT18681);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DECREMENT1315_tree = (Object) this.adaptor.create(DECREMENT1315);
					this.adaptor.addChild(root_0, DECREMENT1315_tree);
				}
				// ../rsc/CSharp.g3:2769:33: ( ignoredtail )?
				int alt340 = 2;
				int LA340_0 = this.input.LA(1);

				if (((LA340_0 >= Whitespace && LA340_0 <= Preprocessordirective))) {
					alt340 = 1;
				}
				switch (alt340) {
					case 1 :
					// ../rsc/CSharp.g3:2769:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dECREMENT18684);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dECREMENT"

	public static class lOGICALAND_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lOGICALAND"
	// ../rsc/CSharp.g3:2770:1: lOGICALAND : LOGICALAND ( ignoredtail )? ;
	public final CSharpParser.lOGICALAND_return lOGICALAND()
			throws RecognitionException {
		CSharpParser.lOGICALAND_return retval =
			new CSharpParser.lOGICALAND_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LOGICALAND1317 = null;
		Object LOGICALAND1317_tree = null;

		try {
			// ../rsc/CSharp.g3:2770:21: ( LOGICALAND ( ignoredtail )? )
			// ../rsc/CSharp.g3:2770:23: LOGICALAND ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LOGICALAND1317 =
					(Token) match(
						this.input,
						LOGICALAND,
						FOLLOW_LOGICALAND_in_lOGICALAND18703);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LOGICALAND1317_tree =
						(Object) this.adaptor.create(LOGICALAND1317);
					this.adaptor.addChild(root_0, LOGICALAND1317_tree);
				}
				// ../rsc/CSharp.g3:2770:34: ( ignoredtail )?
				int alt341 = 2;
				int LA341_0 = this.input.LA(1);

				if (((LA341_0 >= Whitespace && LA341_0 <= Preprocessordirective))) {
					alt341 = 1;
				}
				switch (alt341) {
					case 1 :
					// ../rsc/CSharp.g3:2770:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lOGICALAND18706);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lOGICALAND"

	public static class lOGICALOR_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lOGICALOR"
	// ../rsc/CSharp.g3:2771:1: lOGICALOR : LOGICALOR ( ignoredtail )? ;
	public final CSharpParser.lOGICALOR_return lOGICALOR()
			throws RecognitionException {
		CSharpParser.lOGICALOR_return retval =
			new CSharpParser.lOGICALOR_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LOGICALOR1319 = null;
		Object LOGICALOR1319_tree = null;

		try {
			// ../rsc/CSharp.g3:2771:21: ( LOGICALOR ( ignoredtail )? )
			// ../rsc/CSharp.g3:2771:23: LOGICALOR ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LOGICALOR1319 =
					(Token) match(
						this.input,
						LOGICALOR,
						FOLLOW_LOGICALOR_in_lOGICALOR18726);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LOGICALOR1319_tree = (Object) this.adaptor.create(LOGICALOR1319);
					this.adaptor.addChild(root_0, LOGICALOR1319_tree);
				}
				// ../rsc/CSharp.g3:2771:33: ( ignoredtail )?
				int alt342 = 2;
				int LA342_0 = this.input.LA(1);

				if (((LA342_0 >= Whitespace && LA342_0 <= Preprocessordirective))) {
					alt342 = 1;
				}
				switch (alt342) {
					case 1 :
					// ../rsc/CSharp.g3:2771:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lOGICALOR18729);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lOGICALOR"

	public static class aRROW_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "aRROW"
	// ../rsc/CSharp.g3:2772:1: aRROW : ARROW ( ignoredtail )? ;
	public final CSharpParser.aRROW_return aRROW() throws RecognitionException {
		CSharpParser.aRROW_return retval = new CSharpParser.aRROW_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ARROW1321 = null;
		Object ARROW1321_tree = null;

		try {
			// ../rsc/CSharp.g3:2772:21: ( ARROW ( ignoredtail )? )
			// ../rsc/CSharp.g3:2772:23: ARROW ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ARROW1321 =
					(Token) match(this.input, ARROW, FOLLOW_ARROW_in_aRROW18753);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ARROW1321_tree = (Object) this.adaptor.create(ARROW1321);
					this.adaptor.addChild(root_0, ARROW1321_tree);
				}
				// ../rsc/CSharp.g3:2772:29: ( ignoredtail )?
				int alt343 = 2;
				int LA343_0 = this.input.LA(1);

				if (((LA343_0 >= Whitespace && LA343_0 <= Preprocessordirective))) {
					alt343 = 1;
				}
				switch (alt343) {
					case 1 :
					// ../rsc/CSharp.g3:2772:30: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_aRROW18756);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "aRROW"

	public static class eQUALS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eQUALS"
	// ../rsc/CSharp.g3:2773:1: eQUALS : EQUALS ( ignoredtail )? ;
	public final CSharpParser.eQUALS_return eQUALS()
			throws RecognitionException {
		CSharpParser.eQUALS_return retval = new CSharpParser.eQUALS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token EQUALS1323 = null;
		Object EQUALS1323_tree = null;

		try {
			// ../rsc/CSharp.g3:2773:21: ( EQUALS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2773:23: EQUALS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				EQUALS1323 =
					(Token) match(this.input, EQUALS, FOLLOW_EQUALS_in_eQUALS18779);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					EQUALS1323_tree = (Object) this.adaptor.create(EQUALS1323);
					this.adaptor.addChild(root_0, EQUALS1323_tree);
				}
				// ../rsc/CSharp.g3:2773:30: ( ignoredtail )?
				int alt344 = 2;
				int LA344_0 = this.input.LA(1);

				if (((LA344_0 >= Whitespace && LA344_0 <= Preprocessordirective))) {
					alt344 = 1;
				}
				switch (alt344) {
					case 1 :
					// ../rsc/CSharp.g3:2773:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_eQUALS18782);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eQUALS"

	public static class nOTEQUALS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "nOTEQUALS"
	// ../rsc/CSharp.g3:2774:1: nOTEQUALS : NOTEQUALS ( ignoredtail )? ;
	public final CSharpParser.nOTEQUALS_return nOTEQUALS()
			throws RecognitionException {
		CSharpParser.nOTEQUALS_return retval =
			new CSharpParser.nOTEQUALS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token NOTEQUALS1325 = null;
		Object NOTEQUALS1325_tree = null;

		try {
			// ../rsc/CSharp.g3:2774:21: ( NOTEQUALS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2774:23: NOTEQUALS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				NOTEQUALS1325 =
					(Token) match(
						this.input,
						NOTEQUALS,
						FOLLOW_NOTEQUALS_in_nOTEQUALS18802);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					NOTEQUALS1325_tree = (Object) this.adaptor.create(NOTEQUALS1325);
					this.adaptor.addChild(root_0, NOTEQUALS1325_tree);
				}
				// ../rsc/CSharp.g3:2774:33: ( ignoredtail )?
				int alt345 = 2;
				int LA345_0 = this.input.LA(1);

				if (((LA345_0 >= Whitespace && LA345_0 <= Preprocessordirective))) {
					alt345 = 1;
				}
				switch (alt345) {
					case 1 :
					// ../rsc/CSharp.g3:2774:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_nOTEQUALS18805);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "nOTEQUALS"

	public static class lE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lE"
	// ../rsc/CSharp.g3:2775:1: lE : LE ( ignoredtail )? ;
	public final CSharpParser.lE_return lE() throws RecognitionException {
		CSharpParser.lE_return retval = new CSharpParser.lE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LE1327 = null;
		Object LE1327_tree = null;

		try {
			// ../rsc/CSharp.g3:2775:21: ( LE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2775:23: LE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LE1327 = (Token) match(this.input, LE, FOLLOW_LE_in_lE18832);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LE1327_tree = (Object) this.adaptor.create(LE1327);
					this.adaptor.addChild(root_0, LE1327_tree);
				}
				// ../rsc/CSharp.g3:2775:26: ( ignoredtail )?
				int alt346 = 2;
				int LA346_0 = this.input.LA(1);

				if (((LA346_0 >= Whitespace && LA346_0 <= Preprocessordirective))) {
					alt346 = 1;
				}
				switch (alt346) {
					case 1 :
					// ../rsc/CSharp.g3:2775:27: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lE18835);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lE"

	public static class aDDASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "aDDASSIGN"
	// ../rsc/CSharp.g3:2776:1: aDDASSIGN : ADDASSIGN ( ignoredtail )? ;
	public final CSharpParser.aDDASSIGN_return aDDASSIGN()
			throws RecognitionException {
		CSharpParser.aDDASSIGN_return retval =
			new CSharpParser.aDDASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ADDASSIGN1329 = null;
		Object ADDASSIGN1329_tree = null;

		try {
			// ../rsc/CSharp.g3:2776:21: ( ADDASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2776:23: ADDASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ADDASSIGN1329 =
					(Token) match(
						this.input,
						ADDASSIGN,
						FOLLOW_ADDASSIGN_in_aDDASSIGN18855);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ADDASSIGN1329_tree = (Object) this.adaptor.create(ADDASSIGN1329);
					this.adaptor.addChild(root_0, ADDASSIGN1329_tree);
				}
				// ../rsc/CSharp.g3:2776:33: ( ignoredtail )?
				int alt347 = 2;
				int LA347_0 = this.input.LA(1);

				if (((LA347_0 >= Whitespace && LA347_0 <= Preprocessordirective))) {
					alt347 = 1;
				}
				switch (alt347) {
					case 1 :
					// ../rsc/CSharp.g3:2776:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_aDDASSIGN18858);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "aDDASSIGN"

	public static class sUBASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sUBASSIGN"
	// ../rsc/CSharp.g3:2777:1: sUBASSIGN : SUBASSIGN ( ignoredtail )? ;
	public final CSharpParser.sUBASSIGN_return sUBASSIGN()
			throws RecognitionException {
		CSharpParser.sUBASSIGN_return retval =
			new CSharpParser.sUBASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token SUBASSIGN1331 = null;
		Object SUBASSIGN1331_tree = null;

		try {
			// ../rsc/CSharp.g3:2777:21: ( SUBASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2777:23: SUBASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				SUBASSIGN1331 =
					(Token) match(
						this.input,
						SUBASSIGN,
						FOLLOW_SUBASSIGN_in_sUBASSIGN18878);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					SUBASSIGN1331_tree = (Object) this.adaptor.create(SUBASSIGN1331);
					this.adaptor.addChild(root_0, SUBASSIGN1331_tree);
				}
				// ../rsc/CSharp.g3:2777:33: ( ignoredtail )?
				int alt348 = 2;
				int LA348_0 = this.input.LA(1);

				if (((LA348_0 >= Whitespace && LA348_0 <= Preprocessordirective))) {
					alt348 = 1;
				}
				switch (alt348) {
					case 1 :
					// ../rsc/CSharp.g3:2777:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sUBASSIGN18881);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sUBASSIGN"

	public static class mULASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "mULASSIGN"
	// ../rsc/CSharp.g3:2778:1: mULASSIGN : MULASSIGN ( ignoredtail )? ;
	public final CSharpParser.mULASSIGN_return mULASSIGN()
			throws RecognitionException {
		CSharpParser.mULASSIGN_return retval =
			new CSharpParser.mULASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token MULASSIGN1333 = null;
		Object MULASSIGN1333_tree = null;

		try {
			// ../rsc/CSharp.g3:2778:21: ( MULASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2778:23: MULASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				MULASSIGN1333 =
					(Token) match(
						this.input,
						MULASSIGN,
						FOLLOW_MULASSIGN_in_mULASSIGN18901);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					MULASSIGN1333_tree = (Object) this.adaptor.create(MULASSIGN1333);
					this.adaptor.addChild(root_0, MULASSIGN1333_tree);
				}
				// ../rsc/CSharp.g3:2778:33: ( ignoredtail )?
				int alt349 = 2;
				int LA349_0 = this.input.LA(1);

				if (((LA349_0 >= Whitespace && LA349_0 <= Preprocessordirective))) {
					alt349 = 1;
				}
				switch (alt349) {
					case 1 :
					// ../rsc/CSharp.g3:2778:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_mULASSIGN18904);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "mULASSIGN"

	public static class dIVASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dIVASSIGN"
	// ../rsc/CSharp.g3:2779:1: dIVASSIGN : DIVASSIGN ( ignoredtail )? ;
	public final CSharpParser.dIVASSIGN_return dIVASSIGN()
			throws RecognitionException {
		CSharpParser.dIVASSIGN_return retval =
			new CSharpParser.dIVASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DIVASSIGN1335 = null;
		Object DIVASSIGN1335_tree = null;

		try {
			// ../rsc/CSharp.g3:2779:21: ( DIVASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2779:23: DIVASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DIVASSIGN1335 =
					(Token) match(
						this.input,
						DIVASSIGN,
						FOLLOW_DIVASSIGN_in_dIVASSIGN18924);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DIVASSIGN1335_tree = (Object) this.adaptor.create(DIVASSIGN1335);
					this.adaptor.addChild(root_0, DIVASSIGN1335_tree);
				}
				// ../rsc/CSharp.g3:2779:33: ( ignoredtail )?
				int alt350 = 2;
				int LA350_0 = this.input.LA(1);

				if (((LA350_0 >= Whitespace && LA350_0 <= Preprocessordirective))) {
					alt350 = 1;
				}
				switch (alt350) {
					case 1 :
					// ../rsc/CSharp.g3:2779:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dIVASSIGN18927);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dIVASSIGN"

	public static class mODASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "mODASSIGN"
	// ../rsc/CSharp.g3:2780:1: mODASSIGN : MODASSIGN ( ignoredtail )? ;
	public final CSharpParser.mODASSIGN_return mODASSIGN()
			throws RecognitionException {
		CSharpParser.mODASSIGN_return retval =
			new CSharpParser.mODASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token MODASSIGN1337 = null;
		Object MODASSIGN1337_tree = null;

		try {
			// ../rsc/CSharp.g3:2780:21: ( MODASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2780:23: MODASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				MODASSIGN1337 =
					(Token) match(
						this.input,
						MODASSIGN,
						FOLLOW_MODASSIGN_in_mODASSIGN18947);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					MODASSIGN1337_tree = (Object) this.adaptor.create(MODASSIGN1337);
					this.adaptor.addChild(root_0, MODASSIGN1337_tree);
				}
				// ../rsc/CSharp.g3:2780:33: ( ignoredtail )?
				int alt351 = 2;
				int LA351_0 = this.input.LA(1);

				if (((LA351_0 >= Whitespace && LA351_0 <= Preprocessordirective))) {
					alt351 = 1;
				}
				switch (alt351) {
					case 1 :
					// ../rsc/CSharp.g3:2780:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_mODASSIGN18950);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "mODASSIGN"

	public static class bITWISEANDASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bITWISEANDASSIGN"
	// ../rsc/CSharp.g3:2781:1: bITWISEANDASSIGN : BITWISEANDASSIGN ( ignoredtail )? ;
	public final CSharpParser.bITWISEANDASSIGN_return bITWISEANDASSIGN()
			throws RecognitionException {
		CSharpParser.bITWISEANDASSIGN_return retval =
			new CSharpParser.bITWISEANDASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BITWISEANDASSIGN1339 = null;
		Object BITWISEANDASSIGN1339_tree = null;

		try {
			// ../rsc/CSharp.g3:2781:21: ( BITWISEANDASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2781:23: BITWISEANDASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BITWISEANDASSIGN1339 =
					(Token) match(
						this.input,
						BITWISEANDASSIGN,
						FOLLOW_BITWISEANDASSIGN_in_bITWISEANDASSIGN18963);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BITWISEANDASSIGN1339_tree =
						(Object) this.adaptor.create(BITWISEANDASSIGN1339);
					this.adaptor.addChild(root_0, BITWISEANDASSIGN1339_tree);
				}
				// ../rsc/CSharp.g3:2781:40: ( ignoredtail )?
				int alt352 = 2;
				int LA352_0 = this.input.LA(1);

				if (((LA352_0 >= Whitespace && LA352_0 <= Preprocessordirective))) {
					alt352 = 1;
				}
				switch (alt352) {
					case 1 :
					// ../rsc/CSharp.g3:2781:41: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bITWISEANDASSIGN18966);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bITWISEANDASSIGN"

	public static class bITWISEORASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bITWISEORASSIGN"
	// ../rsc/CSharp.g3:2782:1: bITWISEORASSIGN : BITWISEORASSIGN ( ignoredtail )? ;
	public final CSharpParser.bITWISEORASSIGN_return bITWISEORASSIGN()
			throws RecognitionException {
		CSharpParser.bITWISEORASSIGN_return retval =
			new CSharpParser.bITWISEORASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BITWISEORASSIGN1341 = null;
		Object BITWISEORASSIGN1341_tree = null;

		try {
			// ../rsc/CSharp.g3:2782:21: ( BITWISEORASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2782:23: BITWISEORASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BITWISEORASSIGN1341 =
					(Token) match(
						this.input,
						BITWISEORASSIGN,
						FOLLOW_BITWISEORASSIGN_in_bITWISEORASSIGN18980);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BITWISEORASSIGN1341_tree =
						(Object) this.adaptor.create(BITWISEORASSIGN1341);
					this.adaptor.addChild(root_0, BITWISEORASSIGN1341_tree);
				}
				// ../rsc/CSharp.g3:2782:39: ( ignoredtail )?
				int alt353 = 2;
				int LA353_0 = this.input.LA(1);

				if (((LA353_0 >= Whitespace && LA353_0 <= Preprocessordirective))) {
					alt353 = 1;
				}
				switch (alt353) {
					case 1 :
					// ../rsc/CSharp.g3:2782:40: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bITWISEORASSIGN18983);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bITWISEORASSIGN"

	public static class bITWISEXORASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bITWISEXORASSIGN"
	// ../rsc/CSharp.g3:2783:1: bITWISEXORASSIGN : BITWISEXORASSIGN ( ignoredtail )? ;
	public final CSharpParser.bITWISEXORASSIGN_return bITWISEXORASSIGN()
			throws RecognitionException {
		CSharpParser.bITWISEXORASSIGN_return retval =
			new CSharpParser.bITWISEXORASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BITWISEXORASSIGN1343 = null;
		Object BITWISEXORASSIGN1343_tree = null;

		try {
			// ../rsc/CSharp.g3:2783:21: ( BITWISEXORASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2783:23: BITWISEXORASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BITWISEXORASSIGN1343 =
					(Token) match(
						this.input,
						BITWISEXORASSIGN,
						FOLLOW_BITWISEXORASSIGN_in_bITWISEXORASSIGN18996);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BITWISEXORASSIGN1343_tree =
						(Object) this.adaptor.create(BITWISEXORASSIGN1343);
					this.adaptor.addChild(root_0, BITWISEXORASSIGN1343_tree);
				}
				// ../rsc/CSharp.g3:2783:40: ( ignoredtail )?
				int alt354 = 2;
				int LA354_0 = this.input.LA(1);

				if (((LA354_0 >= Whitespace && LA354_0 <= Preprocessordirective))) {
					alt354 = 1;
				}
				switch (alt354) {
					case 1 :
					// ../rsc/CSharp.g3:2783:41: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bITWISEXORASSIGN18999);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bITWISEXORASSIGN"

	public static class lEFTSHIFT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lEFTSHIFT"
	// ../rsc/CSharp.g3:2784:1: lEFTSHIFT : LEFTSHIFT ( ignoredtail )? ;
	public final CSharpParser.lEFTSHIFT_return lEFTSHIFT()
			throws RecognitionException {
		CSharpParser.lEFTSHIFT_return retval =
			new CSharpParser.lEFTSHIFT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LEFTSHIFT1345 = null;
		Object LEFTSHIFT1345_tree = null;

		try {
			// ../rsc/CSharp.g3:2784:21: ( LEFTSHIFT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2784:23: LEFTSHIFT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LEFTSHIFT1345 =
					(Token) match(
						this.input,
						LEFTSHIFT,
						FOLLOW_LEFTSHIFT_in_lEFTSHIFT19019);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LEFTSHIFT1345_tree = (Object) this.adaptor.create(LEFTSHIFT1345);
					this.adaptor.addChild(root_0, LEFTSHIFT1345_tree);
				}
				// ../rsc/CSharp.g3:2784:33: ( ignoredtail )?
				int alt355 = 2;
				int LA355_0 = this.input.LA(1);

				if (((LA355_0 >= Whitespace && LA355_0 <= Preprocessordirective))) {
					alt355 = 1;
				}
				switch (alt355) {
					case 1 :
					// ../rsc/CSharp.g3:2784:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lEFTSHIFT19022);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lEFTSHIFT"

	public static class lEFTSHIFTASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lEFTSHIFTASSIGN"
	// ../rsc/CSharp.g3:2785:1: lEFTSHIFTASSIGN : LEFTSHIFTASSIGN ( ignoredtail )? ;
	public final CSharpParser.lEFTSHIFTASSIGN_return lEFTSHIFTASSIGN()
			throws RecognitionException {
		CSharpParser.lEFTSHIFTASSIGN_return retval =
			new CSharpParser.lEFTSHIFTASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LEFTSHIFTASSIGN1347 = null;
		Object LEFTSHIFTASSIGN1347_tree = null;

		try {
			// ../rsc/CSharp.g3:2785:21: ( LEFTSHIFTASSIGN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2785:23: LEFTSHIFTASSIGN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LEFTSHIFTASSIGN1347 =
					(Token) match(
						this.input,
						LEFTSHIFTASSIGN,
						FOLLOW_LEFTSHIFTASSIGN_in_lEFTSHIFTASSIGN19036);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LEFTSHIFTASSIGN1347_tree =
						(Object) this.adaptor.create(LEFTSHIFTASSIGN1347);
					this.adaptor.addChild(root_0, LEFTSHIFTASSIGN1347_tree);
				}
				// ../rsc/CSharp.g3:2785:39: ( ignoredtail )?
				int alt356 = 2;
				int LA356_0 = this.input.LA(1);

				if (((LA356_0 >= Whitespace && LA356_0 <= Preprocessordirective))) {
					alt356 = 1;
				}
				switch (alt356) {
					case 1 :
					// ../rsc/CSharp.g3:2785:40: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lEFTSHIFTASSIGN19039);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lEFTSHIFTASSIGN"

	public static class rIGHTSHIFTASSIGN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rIGHTSHIFTASSIGN"
	// ../rsc/CSharp.g3:2787:1: rIGHTSHIFTASSIGN : gt1= GT GT ASSIGN ( ignoredtail )? -> RIGHTSHIFTASSIGN[$gt1, \">>=\"] ;
	public final CSharpParser.rIGHTSHIFTASSIGN_return rIGHTSHIFTASSIGN()
			throws RecognitionException {
		CSharpParser.rIGHTSHIFTASSIGN_return retval =
			new CSharpParser.rIGHTSHIFTASSIGN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token gt1 = null;
		Token GT1349 = null;
		Token ASSIGN1350 = null;
		CSharpParser.ignoredtail_return ignoredtail1351 = null;

		RewriteRuleTokenStream stream_GT =
			new RewriteRuleTokenStream(this.adaptor, "token GT");
		RewriteRuleTokenStream stream_ASSIGN =
			new RewriteRuleTokenStream(this.adaptor, "token ASSIGN");
		RewriteRuleSubtreeStream stream_ignoredtail =
			new RewriteRuleSubtreeStream(this.adaptor, "rule ignoredtail");
		try {
			// ../rsc/CSharp.g3:2787:19: (gt1= GT GT ASSIGN ( ignoredtail )? -> RIGHTSHIFTASSIGN[$gt1, \">>=\"] )
			// ../rsc/CSharp.g3:2787:21: gt1= GT GT ASSIGN ( ignoredtail )?
			{
				gt1 =
					(Token) match(this.input, GT, FOLLOW_GT_in_rIGHTSHIFTASSIGN19053);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_GT.add(gt1);

				GT1349 =
					(Token) match(this.input, GT, FOLLOW_GT_in_rIGHTSHIFTASSIGN19055);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_GT.add(GT1349);

				ASSIGN1350 =
					(Token) match(
						this.input,
						ASSIGN,
						FOLLOW_ASSIGN_in_rIGHTSHIFTASSIGN19057);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_ASSIGN.add(ASSIGN1350);

				// ../rsc/CSharp.g3:2787:38: ( ignoredtail )?
				int alt357 = 2;
				int LA357_0 = this.input.LA(1);

				if (((LA357_0 >= Whitespace && LA357_0 <= Preprocessordirective))) {
					alt357 = 1;
				}
				switch (alt357) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rIGHTSHIFTASSIGN19059);
							ignoredtail1351 = ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_ignoredtail.add(ignoredtail1351
									.getTree());

						}
						break;

				}

				// AST REWRITE
				// elements: 
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2787:51: -> RIGHTSHIFTASSIGN[$gt1, \">>=\"]
					{
						this.adaptor.addChild(root_0, (Object) this.adaptor.create(
							RIGHTSHIFTASSIGN,
							gt1,
							">>="));

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rIGHTSHIFTASSIGN"

	public static class rIGHTSHIFT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rIGHTSHIFT"
	// ../rsc/CSharp.g3:2788:1: rIGHTSHIFT : gt1= GT GT ( ignoredtail )? -> RIGHTSHIFT[$gt1, \">>\"] ;
	public final CSharpParser.rIGHTSHIFT_return rIGHTSHIFT()
			throws RecognitionException {
		CSharpParser.rIGHTSHIFT_return retval =
			new CSharpParser.rIGHTSHIFT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token gt1 = null;
		Token GT1352 = null;
		CSharpParser.ignoredtail_return ignoredtail1353 = null;

		RewriteRuleTokenStream stream_GT =
			new RewriteRuleTokenStream(this.adaptor, "token GT");
		RewriteRuleSubtreeStream stream_ignoredtail =
			new RewriteRuleSubtreeStream(this.adaptor, "rule ignoredtail");
		try {
			// ../rsc/CSharp.g3:2788:14: (gt1= GT GT ( ignoredtail )? -> RIGHTSHIFT[$gt1, \">>\"] )
			// ../rsc/CSharp.g3:2788:16: gt1= GT GT ( ignoredtail )?
			{
				gt1 = (Token) match(this.input, GT, FOLLOW_GT_in_rIGHTSHIFT19076);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_GT.add(gt1);

				GT1352 = (Token) match(this.input, GT, FOLLOW_GT_in_rIGHTSHIFT19078);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_GT.add(GT1352);

				// ../rsc/CSharp.g3:2788:26: ( ignoredtail )?
				int alt358 = 2;
				int LA358_0 = this.input.LA(1);

				if (((LA358_0 >= Whitespace && LA358_0 <= Preprocessordirective))) {
					alt358 = 1;
				}
				switch (alt358) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rIGHTSHIFT19080);
							ignoredtail1353 = ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_ignoredtail.add(ignoredtail1353
									.getTree());

						}
						break;

				}

				// AST REWRITE
				// elements: 
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2788:39: -> RIGHTSHIFT[$gt1, \">>\"]
					{
						this.adaptor.addChild(
							root_0,
							(Object) this.adaptor.create(RIGHTSHIFT, gt1, ">>"));

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rIGHTSHIFT"

	public static class gE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "gE"
	// ../rsc/CSharp.g3:2789:1: gE : GT ASSIGN ( ignoredtail )? -> GE[$GT, \">=\"] ;
	public final CSharpParser.gE_return gE() throws RecognitionException {
		CSharpParser.gE_return retval = new CSharpParser.gE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token GT1354 = null;
		Token ASSIGN1355 = null;
		CSharpParser.ignoredtail_return ignoredtail1356 = null;

		RewriteRuleTokenStream stream_GT =
			new RewriteRuleTokenStream(this.adaptor, "token GT");
		RewriteRuleTokenStream stream_ASSIGN =
			new RewriteRuleTokenStream(this.adaptor, "token ASSIGN");
		RewriteRuleSubtreeStream stream_ignoredtail =
			new RewriteRuleSubtreeStream(this.adaptor, "rule ignoredtail");
		try {
			// ../rsc/CSharp.g3:2789:21: ( GT ASSIGN ( ignoredtail )? -> GE[$GT, \">=\"] )
			// ../rsc/CSharp.g3:2789:23: GT ASSIGN ( ignoredtail )?
			{
				GT1354 = (Token) match(this.input, GT, FOLLOW_GT_in_gE19110);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_GT.add(GT1354);

				ASSIGN1355 =
					(Token) match(this.input, ASSIGN, FOLLOW_ASSIGN_in_gE19112);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0)
					stream_ASSIGN.add(ASSIGN1355);

				// ../rsc/CSharp.g3:2789:33: ( ignoredtail )?
				int alt359 = 2;
				int LA359_0 = this.input.LA(1);

				if (((LA359_0 >= Whitespace && LA359_0 <= Preprocessordirective))) {
					alt359 = 1;
				}
				switch (alt359) {
					case 1 :
					// ../rsc/CSharp.g3:0:0: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_gE19114);
							ignoredtail1356 = ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;
							if (this.state.backtracking == 0)
								stream_ignoredtail.add(ignoredtail1356
									.getTree());

						}
						break;

				}

				// AST REWRITE
				// elements: 
				// token labels: 
				// rule labels: retval
				// token list labels: 
				// rule list labels: 
				// wildcard labels: 
				if (this.state.backtracking == 0) {
					retval.tree = root_0;
					new RewriteRuleSubtreeStream(
						this.adaptor,
						"rule retval",
						retval != null ? retval.tree : null);

					root_0 = (Object) this.adaptor.nil();
					// 2789:46: -> GE[$GT, \">=\"]
					{
						this.adaptor.addChild(
							root_0,
							(Object) this.adaptor.create(GE, GT1354, ">="));

					}

					retval.tree = root_0;
				}
			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "gE"

	public static class gT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "gT"
	// ../rsc/CSharp.g3:2790:1: gT : GT ( ignoredtail )? ;
	public final CSharpParser.gT_return gT() throws RecognitionException {
		CSharpParser.gT_return retval = new CSharpParser.gT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token GT1357 = null;
		Object GT1357_tree = null;

		try {
			// ../rsc/CSharp.g3:2790:21: ( GT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2790:23: GT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				GT1357 = (Token) match(this.input, GT, FOLLOW_GT_in_gT19144);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					GT1357_tree = (Object) this.adaptor.create(GT1357);
					this.adaptor.addChild(root_0, GT1357_tree);
				}
				// ../rsc/CSharp.g3:2790:26: ( ignoredtail )?
				int alt360 = 2;
				int LA360_0 = this.input.LA(1);

				if (((LA360_0 >= Whitespace && LA360_0 <= Preprocessordirective))) {
					alt360 = 1;
				}
				switch (alt360) {
					case 1 :
					// ../rsc/CSharp.g3:2790:27: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_gT19147);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "gT"

	public static class aBSTRACT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "aBSTRACT"
	// ../rsc/CSharp.g3:2794:1: aBSTRACT : ( ABSTRACT )=> ABSTRACT ( ignoredtail )? ;
	public final CSharpParser.aBSTRACT_return aBSTRACT()
			throws RecognitionException {
		CSharpParser.aBSTRACT_return retval =
			new CSharpParser.aBSTRACT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ABSTRACT1359 = null;
		Object ABSTRACT1359_tree = null;

		try {
			// ../rsc/CSharp.g3:2794:11: ( ( ABSTRACT )=> ABSTRACT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2794:13: ( ABSTRACT )=> ABSTRACT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ABSTRACT1359 =
					(Token) match(
						this.input,
						ABSTRACT,
						FOLLOW_ABSTRACT_in_aBSTRACT19167);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ABSTRACT1359_tree = (Object) this.adaptor.create(ABSTRACT1359);
					this.adaptor.addChild(root_0, ABSTRACT1359_tree);
				}
				// ../rsc/CSharp.g3:2794:36: ( ignoredtail )?
				int alt361 = 2;
				int LA361_0 = this.input.LA(1);

				if (((LA361_0 >= Whitespace && LA361_0 <= Preprocessordirective))) {
					alt361 = 1;
				}
				switch (alt361) {
					case 1 :
					// ../rsc/CSharp.g3:2794:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_aBSTRACT19170);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "aBSTRACT"

	public static class aS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "aS"
	// ../rsc/CSharp.g3:2795:1: aS : ( AS )=> AS ( ignoredtail )? ;
	public final CSharpParser.aS_return aS() throws RecognitionException {
		CSharpParser.aS_return retval = new CSharpParser.aS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token AS1361 = null;
		Object AS1361_tree = null;

		try {
			// ../rsc/CSharp.g3:2795:13: ( ( AS )=> AS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2795:15: ( AS )=> AS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				AS1361 = (Token) match(this.input, AS, FOLLOW_AS_in_aS19195);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					AS1361_tree = (Object) this.adaptor.create(AS1361);
					this.adaptor.addChild(root_0, AS1361_tree);
				}
				// ../rsc/CSharp.g3:2795:26: ( ignoredtail )?
				int alt362 = 2;
				int LA362_0 = this.input.LA(1);

				if (((LA362_0 >= Whitespace && LA362_0 <= Preprocessordirective))) {
					alt362 = 1;
				}
				switch (alt362) {
					case 1 :
					// ../rsc/CSharp.g3:2795:27: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_aS19198);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "aS"

	public static class bASE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bASE"
	// ../rsc/CSharp.g3:2796:1: bASE : ( BASE )=> BASE ( ignoredtail )? ;
	public final CSharpParser.bASE_return bASE() throws RecognitionException {
		CSharpParser.bASE_return retval = new CSharpParser.bASE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BASE1363 = null;
		Object BASE1363_tree = null;

		try {
			// ../rsc/CSharp.g3:2796:13: ( ( BASE )=> BASE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2796:15: ( BASE )=> BASE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BASE1363 = (Token) match(this.input, BASE, FOLLOW_BASE_in_bASE19221);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BASE1363_tree = (Object) this.adaptor.create(BASE1363);
					this.adaptor.addChild(root_0, BASE1363_tree);
				}
				// ../rsc/CSharp.g3:2796:30: ( ignoredtail )?
				int alt363 = 2;
				int LA363_0 = this.input.LA(1);

				if (((LA363_0 >= Whitespace && LA363_0 <= Preprocessordirective))) {
					alt363 = 1;
				}
				switch (alt363) {
					case 1 :
					// ../rsc/CSharp.g3:2796:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bASE19224);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bASE"

	public static class bOOL_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bOOL"
	// ../rsc/CSharp.g3:2797:1: bOOL : ( BOOL )=> BOOL ( ignoredtail )? ;
	public final CSharpParser.bOOL_return bOOL() throws RecognitionException {
		CSharpParser.bOOL_return retval = new CSharpParser.bOOL_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BOOL1365 = null;
		Object BOOL1365_tree = null;

		try {
			// ../rsc/CSharp.g3:2797:13: ( ( BOOL )=> BOOL ( ignoredtail )? )
			// ../rsc/CSharp.g3:2797:15: ( BOOL )=> BOOL ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BOOL1365 = (Token) match(this.input, BOOL, FOLLOW_BOOL_in_bOOL19247);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BOOL1365_tree = (Object) this.adaptor.create(BOOL1365);
					this.adaptor.addChild(root_0, BOOL1365_tree);
				}
				// ../rsc/CSharp.g3:2797:30: ( ignoredtail )?
				int alt364 = 2;
				int LA364_0 = this.input.LA(1);

				if (((LA364_0 >= Whitespace && LA364_0 <= Preprocessordirective))) {
					alt364 = 1;
				}
				switch (alt364) {
					case 1 :
					// ../rsc/CSharp.g3:2797:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bOOL19250);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bOOL"

	public static class bREAK_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bREAK"
	// ../rsc/CSharp.g3:2798:1: bREAK : ( BREAK )=> BREAK ( ignoredtail )? ;
	public final CSharpParser.bREAK_return bREAK() throws RecognitionException {
		CSharpParser.bREAK_return retval = new CSharpParser.bREAK_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BREAK1367 = null;
		Object BREAK1367_tree = null;

		try {
			// ../rsc/CSharp.g3:2798:13: ( ( BREAK )=> BREAK ( ignoredtail )? )
			// ../rsc/CSharp.g3:2798:15: ( BREAK )=> BREAK ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BREAK1367 =
					(Token) match(this.input, BREAK, FOLLOW_BREAK_in_bREAK19272);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BREAK1367_tree = (Object) this.adaptor.create(BREAK1367);
					this.adaptor.addChild(root_0, BREAK1367_tree);
				}
				// ../rsc/CSharp.g3:2798:32: ( ignoredtail )?
				int alt365 = 2;
				int LA365_0 = this.input.LA(1);

				if (((LA365_0 >= Whitespace && LA365_0 <= Preprocessordirective))) {
					alt365 = 1;
				}
				switch (alt365) {
					case 1 :
					// ../rsc/CSharp.g3:2798:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bREAK19275);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bREAK"

	public static class bYTE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "bYTE"
	// ../rsc/CSharp.g3:2799:1: bYTE : ( BYTE )=> BYTE ( ignoredtail )? ;
	public final CSharpParser.bYTE_return bYTE() throws RecognitionException {
		CSharpParser.bYTE_return retval = new CSharpParser.bYTE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token BYTE1369 = null;
		Object BYTE1369_tree = null;

		try {
			// ../rsc/CSharp.g3:2799:13: ( ( BYTE )=> BYTE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2799:15: ( BYTE )=> BYTE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				BYTE1369 = (Token) match(this.input, BYTE, FOLLOW_BYTE_in_bYTE19298);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					BYTE1369_tree = (Object) this.adaptor.create(BYTE1369);
					this.adaptor.addChild(root_0, BYTE1369_tree);
				}
				// ../rsc/CSharp.g3:2799:30: ( ignoredtail )?
				int alt366 = 2;
				int LA366_0 = this.input.LA(1);

				if (((LA366_0 >= Whitespace && LA366_0 <= Preprocessordirective))) {
					alt366 = 1;
				}
				switch (alt366) {
					case 1 :
					// ../rsc/CSharp.g3:2799:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_bYTE19301);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "bYTE"

	public static class cASE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cASE"
	// ../rsc/CSharp.g3:2800:1: cASE : ( CASE )=> CASE ( ignoredtail )? ;
	public final CSharpParser.cASE_return cASE() throws RecognitionException {
		CSharpParser.cASE_return retval = new CSharpParser.cASE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token CASE1371 = null;
		Object CASE1371_tree = null;

		try {
			// ../rsc/CSharp.g3:2800:13: ( ( CASE )=> CASE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2800:15: ( CASE )=> CASE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				CASE1371 = (Token) match(this.input, CASE, FOLLOW_CASE_in_cASE19324);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					CASE1371_tree = (Object) this.adaptor.create(CASE1371);
					this.adaptor.addChild(root_0, CASE1371_tree);
				}
				// ../rsc/CSharp.g3:2800:30: ( ignoredtail )?
				int alt367 = 2;
				int LA367_0 = this.input.LA(1);

				if (((LA367_0 >= Whitespace && LA367_0 <= Preprocessordirective))) {
					alt367 = 1;
				}
				switch (alt367) {
					case 1 :
					// ../rsc/CSharp.g3:2800:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cASE19327);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cASE"

	public static class cATCH_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cATCH"
	// ../rsc/CSharp.g3:2801:1: cATCH : ( CATCH )=> CATCH ( ignoredtail )? ;
	public final CSharpParser.cATCH_return cATCH() throws RecognitionException {
		CSharpParser.cATCH_return retval = new CSharpParser.cATCH_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token CATCH1373 = null;
		Object CATCH1373_tree = null;

		try {
			// ../rsc/CSharp.g3:2801:13: ( ( CATCH )=> CATCH ( ignoredtail )? )
			// ../rsc/CSharp.g3:2801:15: ( CATCH )=> CATCH ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				CATCH1373 =
					(Token) match(this.input, CATCH, FOLLOW_CATCH_in_cATCH19349);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					CATCH1373_tree = (Object) this.adaptor.create(CATCH1373);
					this.adaptor.addChild(root_0, CATCH1373_tree);
				}
				// ../rsc/CSharp.g3:2801:32: ( ignoredtail )?
				int alt368 = 2;
				int LA368_0 = this.input.LA(1);

				if (((LA368_0 >= Whitespace && LA368_0 <= Preprocessordirective))) {
					alt368 = 1;
				}
				switch (alt368) {
					case 1 :
					// ../rsc/CSharp.g3:2801:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cATCH19352);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cATCH"

	public static class cHAR_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cHAR"
	// ../rsc/CSharp.g3:2802:1: cHAR : ( CHAR )=> CHAR ( ignoredtail )? ;
	public final CSharpParser.cHAR_return cHAR() throws RecognitionException {
		CSharpParser.cHAR_return retval = new CSharpParser.cHAR_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token CHAR1375 = null;
		Object CHAR1375_tree = null;

		try {
			// ../rsc/CSharp.g3:2802:13: ( ( CHAR )=> CHAR ( ignoredtail )? )
			// ../rsc/CSharp.g3:2802:15: ( CHAR )=> CHAR ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				CHAR1375 = (Token) match(this.input, CHAR, FOLLOW_CHAR_in_cHAR19375);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					CHAR1375_tree = (Object) this.adaptor.create(CHAR1375);
					this.adaptor.addChild(root_0, CHAR1375_tree);
				}
				// ../rsc/CSharp.g3:2802:30: ( ignoredtail )?
				int alt369 = 2;
				int LA369_0 = this.input.LA(1);

				if (((LA369_0 >= Whitespace && LA369_0 <= Preprocessordirective))) {
					alt369 = 1;
				}
				switch (alt369) {
					case 1 :
					// ../rsc/CSharp.g3:2802:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cHAR19378);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cHAR"

	public static class cHECKED_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cHECKED"
	// ../rsc/CSharp.g3:2803:1: cHECKED : ( CHECKED )=> CHECKED ( ignoredtail )? ;
	public final CSharpParser.cHECKED_return cHECKED()
			throws RecognitionException {
		CSharpParser.cHECKED_return retval = new CSharpParser.cHECKED_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token CHECKED1377 = null;
		Object CHECKED1377_tree = null;

		try {
			// ../rsc/CSharp.g3:2803:13: ( ( CHECKED )=> CHECKED ( ignoredtail )? )
			// ../rsc/CSharp.g3:2803:15: ( CHECKED )=> CHECKED ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				CHECKED1377 =
					(Token) match(
						this.input,
						CHECKED,
						FOLLOW_CHECKED_in_cHECKED19398);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					CHECKED1377_tree = (Object) this.adaptor.create(CHECKED1377);
					this.adaptor.addChild(root_0, CHECKED1377_tree);
				}
				// ../rsc/CSharp.g3:2803:36: ( ignoredtail )?
				int alt370 = 2;
				int LA370_0 = this.input.LA(1);

				if (((LA370_0 >= Whitespace && LA370_0 <= Preprocessordirective))) {
					alt370 = 1;
				}
				switch (alt370) {
					case 1 :
					// ../rsc/CSharp.g3:2803:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cHECKED19401);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cHECKED"

	public static class cLASS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cLASS"
	// ../rsc/CSharp.g3:2804:1: cLASS : ( CLASS )=> CLASS ( ignoredtail )? ;
	public final CSharpParser.cLASS_return cLASS() throws RecognitionException {
		CSharpParser.cLASS_return retval = new CSharpParser.cLASS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token CLASS1379 = null;
		Object CLASS1379_tree = null;

		try {
			// ../rsc/CSharp.g3:2804:13: ( ( CLASS )=> CLASS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2804:15: ( CLASS )=> CLASS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				CLASS1379 =
					(Token) match(this.input, CLASS, FOLLOW_CLASS_in_cLASS19423);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					CLASS1379_tree = (Object) this.adaptor.create(CLASS1379);
					this.adaptor.addChild(root_0, CLASS1379_tree);
				}
				// ../rsc/CSharp.g3:2804:32: ( ignoredtail )?
				int alt371 = 2;
				int LA371_0 = this.input.LA(1);

				if (((LA371_0 >= Whitespace && LA371_0 <= Preprocessordirective))) {
					alt371 = 1;
				}
				switch (alt371) {
					case 1 :
					// ../rsc/CSharp.g3:2804:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cLASS19426);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cLASS"

	public static class cONST_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cONST"
	// ../rsc/CSharp.g3:2805:1: cONST : ( CONST )=> CONST ( ignoredtail )? ;
	public final CSharpParser.cONST_return cONST() throws RecognitionException {
		CSharpParser.cONST_return retval = new CSharpParser.cONST_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token CONST1381 = null;
		Object CONST1381_tree = null;

		try {
			// ../rsc/CSharp.g3:2805:13: ( ( CONST )=> CONST ( ignoredtail )? )
			// ../rsc/CSharp.g3:2805:15: ( CONST )=> CONST ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				CONST1381 =
					(Token) match(this.input, CONST, FOLLOW_CONST_in_cONST19448);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					CONST1381_tree = (Object) this.adaptor.create(CONST1381);
					this.adaptor.addChild(root_0, CONST1381_tree);
				}
				// ../rsc/CSharp.g3:2805:32: ( ignoredtail )?
				int alt372 = 2;
				int LA372_0 = this.input.LA(1);

				if (((LA372_0 >= Whitespace && LA372_0 <= Preprocessordirective))) {
					alt372 = 1;
				}
				switch (alt372) {
					case 1 :
					// ../rsc/CSharp.g3:2805:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cONST19451);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cONST"

	public static class cONTINUE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "cONTINUE"
	// ../rsc/CSharp.g3:2806:1: cONTINUE : ( CONTINUE )=> CONTINUE ( ignoredtail )? ;
	public final CSharpParser.cONTINUE_return cONTINUE()
			throws RecognitionException {
		CSharpParser.cONTINUE_return retval =
			new CSharpParser.cONTINUE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token CONTINUE1383 = null;
		Object CONTINUE1383_tree = null;

		try {
			// ../rsc/CSharp.g3:2806:13: ( ( CONTINUE )=> CONTINUE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2806:15: ( CONTINUE )=> CONTINUE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				CONTINUE1383 =
					(Token) match(
						this.input,
						CONTINUE,
						FOLLOW_CONTINUE_in_cONTINUE19470);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					CONTINUE1383_tree = (Object) this.adaptor.create(CONTINUE1383);
					this.adaptor.addChild(root_0, CONTINUE1383_tree);
				}
				// ../rsc/CSharp.g3:2806:38: ( ignoredtail )?
				int alt373 = 2;
				int LA373_0 = this.input.LA(1);

				if (((LA373_0 >= Whitespace && LA373_0 <= Preprocessordirective))) {
					alt373 = 1;
				}
				switch (alt373) {
					case 1 :
					// ../rsc/CSharp.g3:2806:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_cONTINUE19473);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "cONTINUE"

	public static class dECIMAL_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dECIMAL"
	// ../rsc/CSharp.g3:2807:1: dECIMAL : ( DECIMAL )=> DECIMAL ( ignoredtail )? ;
	public final CSharpParser.dECIMAL_return dECIMAL()
			throws RecognitionException {
		CSharpParser.dECIMAL_return retval = new CSharpParser.dECIMAL_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DECIMAL1385 = null;
		Object DECIMAL1385_tree = null;

		try {
			// ../rsc/CSharp.g3:2807:13: ( ( DECIMAL )=> DECIMAL ( ignoredtail )? )
			// ../rsc/CSharp.g3:2807:15: ( DECIMAL )=> DECIMAL ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DECIMAL1385 =
					(Token) match(
						this.input,
						DECIMAL,
						FOLLOW_DECIMAL_in_dECIMAL19493);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DECIMAL1385_tree = (Object) this.adaptor.create(DECIMAL1385);
					this.adaptor.addChild(root_0, DECIMAL1385_tree);
				}
				// ../rsc/CSharp.g3:2807:36: ( ignoredtail )?
				int alt374 = 2;
				int LA374_0 = this.input.LA(1);

				if (((LA374_0 >= Whitespace && LA374_0 <= Preprocessordirective))) {
					alt374 = 1;
				}
				switch (alt374) {
					case 1 :
					// ../rsc/CSharp.g3:2807:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dECIMAL19496);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dECIMAL"

	public static class dEFAULT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dEFAULT"
	// ../rsc/CSharp.g3:2808:1: dEFAULT : ( DEFAULT )=> DEFAULT ( ignoredtail )? ;
	public final CSharpParser.dEFAULT_return dEFAULT()
			throws RecognitionException {
		CSharpParser.dEFAULT_return retval = new CSharpParser.dEFAULT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DEFAULT1387 = null;
		Object DEFAULT1387_tree = null;

		try {
			// ../rsc/CSharp.g3:2808:13: ( ( DEFAULT )=> DEFAULT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2808:15: ( DEFAULT )=> DEFAULT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DEFAULT1387 =
					(Token) match(
						this.input,
						DEFAULT,
						FOLLOW_DEFAULT_in_dEFAULT19516);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DEFAULT1387_tree = (Object) this.adaptor.create(DEFAULT1387);
					this.adaptor.addChild(root_0, DEFAULT1387_tree);
				}
				// ../rsc/CSharp.g3:2808:36: ( ignoredtail )?
				int alt375 = 2;
				int LA375_0 = this.input.LA(1);

				if (((LA375_0 >= Whitespace && LA375_0 <= Preprocessordirective))) {
					alt375 = 1;
				}
				switch (alt375) {
					case 1 :
					// ../rsc/CSharp.g3:2808:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dEFAULT19519);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dEFAULT"

	public static class dELEGATE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dELEGATE"
	// ../rsc/CSharp.g3:2809:1: dELEGATE : ( DELEGATE )=> DELEGATE ( ignoredtail )? ;
	public final CSharpParser.dELEGATE_return dELEGATE()
			throws RecognitionException {
		CSharpParser.dELEGATE_return retval =
			new CSharpParser.dELEGATE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DELEGATE1389 = null;
		Object DELEGATE1389_tree = null;

		try {
			// ../rsc/CSharp.g3:2809:13: ( ( DELEGATE )=> DELEGATE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2809:15: ( DELEGATE )=> DELEGATE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DELEGATE1389 =
					(Token) match(
						this.input,
						DELEGATE,
						FOLLOW_DELEGATE_in_dELEGATE19538);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DELEGATE1389_tree = (Object) this.adaptor.create(DELEGATE1389);
					this.adaptor.addChild(root_0, DELEGATE1389_tree);
				}
				// ../rsc/CSharp.g3:2809:38: ( ignoredtail )?
				int alt376 = 2;
				int LA376_0 = this.input.LA(1);

				if (((LA376_0 >= Whitespace && LA376_0 <= Preprocessordirective))) {
					alt376 = 1;
				}
				switch (alt376) {
					case 1 :
					// ../rsc/CSharp.g3:2809:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dELEGATE19541);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dELEGATE"

	public static class dO_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dO"
	// ../rsc/CSharp.g3:2810:1: dO : ( DO )=> DO ( ignoredtail )? ;
	public final CSharpParser.dO_return dO() throws RecognitionException {
		CSharpParser.dO_return retval = new CSharpParser.dO_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DO1391 = null;
		Object DO1391_tree = null;

		try {
			// ../rsc/CSharp.g3:2810:13: ( ( DO )=> DO ( ignoredtail )? )
			// ../rsc/CSharp.g3:2810:15: ( DO )=> DO ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DO1391 = (Token) match(this.input, DO, FOLLOW_DO_in_dO19566);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DO1391_tree = (Object) this.adaptor.create(DO1391);
					this.adaptor.addChild(root_0, DO1391_tree);
				}
				// ../rsc/CSharp.g3:2810:26: ( ignoredtail )?
				int alt377 = 2;
				int LA377_0 = this.input.LA(1);

				if (((LA377_0 >= Whitespace && LA377_0 <= Preprocessordirective))) {
					alt377 = 1;
				}
				switch (alt377) {
					case 1 :
					// ../rsc/CSharp.g3:2810:27: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dO19569);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dO"

	public static class dOUBLE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "dOUBLE"
	// ../rsc/CSharp.g3:2811:1: dOUBLE : ( DOUBLE )=> DOUBLE ( ignoredtail )? ;
	public final CSharpParser.dOUBLE_return dOUBLE()
			throws RecognitionException {
		CSharpParser.dOUBLE_return retval = new CSharpParser.dOUBLE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token DOUBLE1393 = null;
		Object DOUBLE1393_tree = null;

		try {
			// ../rsc/CSharp.g3:2811:13: ( ( DOUBLE )=> DOUBLE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2811:15: ( DOUBLE )=> DOUBLE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				DOUBLE1393 =
					(Token) match(this.input, DOUBLE, FOLLOW_DOUBLE_in_dOUBLE19590);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					DOUBLE1393_tree = (Object) this.adaptor.create(DOUBLE1393);
					this.adaptor.addChild(root_0, DOUBLE1393_tree);
				}
				// ../rsc/CSharp.g3:2811:34: ( ignoredtail )?
				int alt378 = 2;
				int LA378_0 = this.input.LA(1);

				if (((LA378_0 >= Whitespace && LA378_0 <= Preprocessordirective))) {
					alt378 = 1;
				}
				switch (alt378) {
					case 1 :
					// ../rsc/CSharp.g3:2811:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_dOUBLE19593);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "dOUBLE"

	public static class eLSE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eLSE"
	// ../rsc/CSharp.g3:2812:1: eLSE : ( ELSE )=> ELSE ( ignoredtail )? ;
	public final CSharpParser.eLSE_return eLSE() throws RecognitionException {
		CSharpParser.eLSE_return retval = new CSharpParser.eLSE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ELSE1395 = null;
		Object ELSE1395_tree = null;

		try {
			// ../rsc/CSharp.g3:2812:13: ( ( ELSE )=> ELSE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2812:15: ( ELSE )=> ELSE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ELSE1395 = (Token) match(this.input, ELSE, FOLLOW_ELSE_in_eLSE19616);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ELSE1395_tree = (Object) this.adaptor.create(ELSE1395);
					this.adaptor.addChild(root_0, ELSE1395_tree);
				}
				// ../rsc/CSharp.g3:2812:30: ( ignoredtail )?
				int alt379 = 2;
				int LA379_0 = this.input.LA(1);

				if (((LA379_0 >= Whitespace && LA379_0 <= Preprocessordirective))) {
					alt379 = 1;
				}
				switch (alt379) {
					case 1 :
					// ../rsc/CSharp.g3:2812:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_eLSE19619);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eLSE"

	public static class eNUM_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eNUM"
	// ../rsc/CSharp.g3:2813:1: eNUM : ( ENUM )=> ENUM ( ignoredtail )? ;
	public final CSharpParser.eNUM_return eNUM() throws RecognitionException {
		CSharpParser.eNUM_return retval = new CSharpParser.eNUM_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ENUM1397 = null;
		Object ENUM1397_tree = null;

		try {
			// ../rsc/CSharp.g3:2813:13: ( ( ENUM )=> ENUM ( ignoredtail )? )
			// ../rsc/CSharp.g3:2813:15: ( ENUM )=> ENUM ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ENUM1397 = (Token) match(this.input, ENUM, FOLLOW_ENUM_in_eNUM19642);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ENUM1397_tree = (Object) this.adaptor.create(ENUM1397);
					this.adaptor.addChild(root_0, ENUM1397_tree);
				}
				// ../rsc/CSharp.g3:2813:30: ( ignoredtail )?
				int alt380 = 2;
				int LA380_0 = this.input.LA(1);

				if (((LA380_0 >= Whitespace && LA380_0 <= Preprocessordirective))) {
					alt380 = 1;
				}
				switch (alt380) {
					case 1 :
					// ../rsc/CSharp.g3:2813:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_eNUM19645);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eNUM"

	public static class eVENT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eVENT"
	// ../rsc/CSharp.g3:2814:1: eVENT : ( EVENT )=> EVENT ( ignoredtail )? ;
	public final CSharpParser.eVENT_return eVENT() throws RecognitionException {
		CSharpParser.eVENT_return retval = new CSharpParser.eVENT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token EVENT1399 = null;
		Object EVENT1399_tree = null;

		try {
			// ../rsc/CSharp.g3:2814:13: ( ( EVENT )=> EVENT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2814:15: ( EVENT )=> EVENT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				EVENT1399 =
					(Token) match(this.input, EVENT, FOLLOW_EVENT_in_eVENT19667);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					EVENT1399_tree = (Object) this.adaptor.create(EVENT1399);
					this.adaptor.addChild(root_0, EVENT1399_tree);
				}
				// ../rsc/CSharp.g3:2814:32: ( ignoredtail )?
				int alt381 = 2;
				int LA381_0 = this.input.LA(1);

				if (((LA381_0 >= Whitespace && LA381_0 <= Preprocessordirective))) {
					alt381 = 1;
				}
				switch (alt381) {
					case 1 :
					// ../rsc/CSharp.g3:2814:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_eVENT19670);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eVENT"

	public static class eXPLICIT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eXPLICIT"
	// ../rsc/CSharp.g3:2815:1: eXPLICIT : ( EXPLICIT )=> EXPLICIT ( ignoredtail )? ;
	public final CSharpParser.eXPLICIT_return eXPLICIT()
			throws RecognitionException {
		CSharpParser.eXPLICIT_return retval =
			new CSharpParser.eXPLICIT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token EXPLICIT1401 = null;
		Object EXPLICIT1401_tree = null;

		try {
			// ../rsc/CSharp.g3:2815:13: ( ( EXPLICIT )=> EXPLICIT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2815:15: ( EXPLICIT )=> EXPLICIT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				EXPLICIT1401 =
					(Token) match(
						this.input,
						EXPLICIT,
						FOLLOW_EXPLICIT_in_eXPLICIT19689);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					EXPLICIT1401_tree = (Object) this.adaptor.create(EXPLICIT1401);
					this.adaptor.addChild(root_0, EXPLICIT1401_tree);
				}
				// ../rsc/CSharp.g3:2815:38: ( ignoredtail )?
				int alt382 = 2;
				int LA382_0 = this.input.LA(1);

				if (((LA382_0 >= Whitespace && LA382_0 <= Preprocessordirective))) {
					alt382 = 1;
				}
				switch (alt382) {
					case 1 :
					// ../rsc/CSharp.g3:2815:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_eXPLICIT19692);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eXPLICIT"

	public static class eXTERN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "eXTERN"
	// ../rsc/CSharp.g3:2816:1: eXTERN : ( EXTERN )=> EXTERN ( ignoredtail )? ;
	public final CSharpParser.eXTERN_return eXTERN()
			throws RecognitionException {
		CSharpParser.eXTERN_return retval = new CSharpParser.eXTERN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token EXTERN1403 = null;
		Object EXTERN1403_tree = null;

		try {
			// ../rsc/CSharp.g3:2816:13: ( ( EXTERN )=> EXTERN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2816:15: ( EXTERN )=> EXTERN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				EXTERN1403 =
					(Token) match(this.input, EXTERN, FOLLOW_EXTERN_in_eXTERN19713);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					EXTERN1403_tree = (Object) this.adaptor.create(EXTERN1403);
					this.adaptor.addChild(root_0, EXTERN1403_tree);
				}
				// ../rsc/CSharp.g3:2816:34: ( ignoredtail )?
				int alt383 = 2;
				int LA383_0 = this.input.LA(1);

				if (((LA383_0 >= Whitespace && LA383_0 <= Preprocessordirective))) {
					alt383 = 1;
				}
				switch (alt383) {
					case 1 :
					// ../rsc/CSharp.g3:2816:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_eXTERN19716);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "eXTERN"

	public static class fALSE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fALSE"
	// ../rsc/CSharp.g3:2817:1: fALSE : ( FALSE )=> FALSE ( ignoredtail )? ;
	public final CSharpParser.fALSE_return fALSE() throws RecognitionException {
		CSharpParser.fALSE_return retval = new CSharpParser.fALSE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token FALSE1405 = null;
		Object FALSE1405_tree = null;

		try {
			// ../rsc/CSharp.g3:2817:13: ( ( FALSE )=> FALSE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2817:15: ( FALSE )=> FALSE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				FALSE1405 =
					(Token) match(this.input, FALSE, FOLLOW_FALSE_in_fALSE19738);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					FALSE1405_tree = (Object) this.adaptor.create(FALSE1405);
					this.adaptor.addChild(root_0, FALSE1405_tree);
				}
				// ../rsc/CSharp.g3:2817:32: ( ignoredtail )?
				int alt384 = 2;
				int LA384_0 = this.input.LA(1);

				if (((LA384_0 >= Whitespace && LA384_0 <= Preprocessordirective))) {
					alt384 = 1;
				}
				switch (alt384) {
					case 1 :
					// ../rsc/CSharp.g3:2817:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_fALSE19741);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fALSE"

	public static class fINALLY_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fINALLY"
	// ../rsc/CSharp.g3:2818:1: fINALLY : ( FINALLY )=> FINALLY ( ignoredtail )? ;
	public final CSharpParser.fINALLY_return fINALLY()
			throws RecognitionException {
		CSharpParser.fINALLY_return retval = new CSharpParser.fINALLY_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token FINALLY1407 = null;
		Object FINALLY1407_tree = null;

		try {
			// ../rsc/CSharp.g3:2818:13: ( ( FINALLY )=> FINALLY ( ignoredtail )? )
			// ../rsc/CSharp.g3:2818:15: ( FINALLY )=> FINALLY ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				FINALLY1407 =
					(Token) match(
						this.input,
						FINALLY,
						FOLLOW_FINALLY_in_fINALLY19761);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					FINALLY1407_tree = (Object) this.adaptor.create(FINALLY1407);
					this.adaptor.addChild(root_0, FINALLY1407_tree);
				}
				// ../rsc/CSharp.g3:2818:36: ( ignoredtail )?
				int alt385 = 2;
				int LA385_0 = this.input.LA(1);

				if (((LA385_0 >= Whitespace && LA385_0 <= Preprocessordirective))) {
					alt385 = 1;
				}
				switch (alt385) {
					case 1 :
					// ../rsc/CSharp.g3:2818:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_fINALLY19764);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fINALLY"

	public static class fIXED_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fIXED"
	// ../rsc/CSharp.g3:2819:1: fIXED : ( FIXED )=> FIXED ( ignoredtail )? ;
	public final CSharpParser.fIXED_return fIXED() throws RecognitionException {
		CSharpParser.fIXED_return retval = new CSharpParser.fIXED_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token FIXED1409 = null;
		Object FIXED1409_tree = null;

		try {
			// ../rsc/CSharp.g3:2819:13: ( ( FIXED )=> FIXED ( ignoredtail )? )
			// ../rsc/CSharp.g3:2819:15: ( FIXED )=> FIXED ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				FIXED1409 =
					(Token) match(this.input, FIXED, FOLLOW_FIXED_in_fIXED19787);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					FIXED1409_tree = (Object) this.adaptor.create(FIXED1409);
					this.adaptor.addChild(root_0, FIXED1409_tree);
				}
				// ../rsc/CSharp.g3:2819:33: ( ignoredtail )?
				int alt386 = 2;
				int LA386_0 = this.input.LA(1);

				if (((LA386_0 >= Whitespace && LA386_0 <= Preprocessordirective))) {
					alt386 = 1;
				}
				switch (alt386) {
					case 1 :
					// ../rsc/CSharp.g3:2819:34: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_fIXED19790);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fIXED"

	public static class fLOAT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fLOAT"
	// ../rsc/CSharp.g3:2820:1: fLOAT : ( FLOAT )=> FLOAT ( ignoredtail )? ;
	public final CSharpParser.fLOAT_return fLOAT() throws RecognitionException {
		CSharpParser.fLOAT_return retval = new CSharpParser.fLOAT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token FLOAT1411 = null;
		Object FLOAT1411_tree = null;

		try {
			// ../rsc/CSharp.g3:2820:13: ( ( FLOAT )=> FLOAT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2820:15: ( FLOAT )=> FLOAT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				FLOAT1411 =
					(Token) match(this.input, FLOAT, FOLLOW_FLOAT_in_fLOAT19812);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					FLOAT1411_tree = (Object) this.adaptor.create(FLOAT1411);
					this.adaptor.addChild(root_0, FLOAT1411_tree);
				}
				// ../rsc/CSharp.g3:2820:32: ( ignoredtail )?
				int alt387 = 2;
				int LA387_0 = this.input.LA(1);

				if (((LA387_0 >= Whitespace && LA387_0 <= Preprocessordirective))) {
					alt387 = 1;
				}
				switch (alt387) {
					case 1 :
					// ../rsc/CSharp.g3:2820:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_fLOAT19815);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fLOAT"

	public static class fOR_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fOR"
	// ../rsc/CSharp.g3:2821:1: fOR : ( FOR )=> FOR ( ignoredtail )? ;
	public final CSharpParser.fOR_return fOR() throws RecognitionException {
		CSharpParser.fOR_return retval = new CSharpParser.fOR_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token FOR1413 = null;
		Object FOR1413_tree = null;

		try {
			// ../rsc/CSharp.g3:2821:13: ( ( FOR )=> FOR ( ignoredtail )? )
			// ../rsc/CSharp.g3:2821:15: ( FOR )=> FOR ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				FOR1413 = (Token) match(this.input, FOR, FOLLOW_FOR_in_fOR19839);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					FOR1413_tree = (Object) this.adaptor.create(FOR1413);
					this.adaptor.addChild(root_0, FOR1413_tree);
				}
				// ../rsc/CSharp.g3:2821:28: ( ignoredtail )?
				int alt388 = 2;
				int LA388_0 = this.input.LA(1);

				if (((LA388_0 >= Whitespace && LA388_0 <= Preprocessordirective))) {
					alt388 = 1;
				}
				switch (alt388) {
					case 1 :
					// ../rsc/CSharp.g3:2821:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_fOR19842);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fOR"

	public static class fOREACH_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "fOREACH"
	// ../rsc/CSharp.g3:2822:1: fOREACH : ( FOREACH )=> FOREACH ( ignoredtail )? ;
	public final CSharpParser.fOREACH_return fOREACH()
			throws RecognitionException {
		CSharpParser.fOREACH_return retval = new CSharpParser.fOREACH_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token FOREACH1415 = null;
		Object FOREACH1415_tree = null;

		try {
			// ../rsc/CSharp.g3:2822:13: ( ( FOREACH )=> FOREACH ( ignoredtail )? )
			// ../rsc/CSharp.g3:2822:15: ( FOREACH )=> FOREACH ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				FOREACH1415 =
					(Token) match(
						this.input,
						FOREACH,
						FOLLOW_FOREACH_in_fOREACH19862);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					FOREACH1415_tree = (Object) this.adaptor.create(FOREACH1415);
					this.adaptor.addChild(root_0, FOREACH1415_tree);
				}
				// ../rsc/CSharp.g3:2822:36: ( ignoredtail )?
				int alt389 = 2;
				int LA389_0 = this.input.LA(1);

				if (((LA389_0 >= Whitespace && LA389_0 <= Preprocessordirective))) {
					alt389 = 1;
				}
				switch (alt389) {
					case 1 :
					// ../rsc/CSharp.g3:2822:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_fOREACH19865);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "fOREACH"

	public static class gOTO_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "gOTO"
	// ../rsc/CSharp.g3:2823:1: gOTO : ( GOTO )=> GOTO ( ignoredtail )? ;
	public final CSharpParser.gOTO_return gOTO() throws RecognitionException {
		CSharpParser.gOTO_return retval = new CSharpParser.gOTO_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token GOTO1417 = null;
		Object GOTO1417_tree = null;

		try {
			// ../rsc/CSharp.g3:2823:13: ( ( GOTO )=> GOTO ( ignoredtail )? )
			// ../rsc/CSharp.g3:2823:15: ( GOTO )=> GOTO ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				GOTO1417 = (Token) match(this.input, GOTO, FOLLOW_GOTO_in_gOTO19888);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					GOTO1417_tree = (Object) this.adaptor.create(GOTO1417);
					this.adaptor.addChild(root_0, GOTO1417_tree);
				}
				// ../rsc/CSharp.g3:2823:30: ( ignoredtail )?
				int alt390 = 2;
				int LA390_0 = this.input.LA(1);

				if (((LA390_0 >= Whitespace && LA390_0 <= Preprocessordirective))) {
					alt390 = 1;
				}
				switch (alt390) {
					case 1 :
					// ../rsc/CSharp.g3:2823:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_gOTO19891);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "gOTO"

	public static class iF_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iF"
	// ../rsc/CSharp.g3:2824:1: iF : ( IF )=> IF ( ignoredtail )? ;
	public final CSharpParser.iF_return iF() throws RecognitionException {
		CSharpParser.iF_return retval = new CSharpParser.iF_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token IF1419 = null;
		Object IF1419_tree = null;

		try {
			// ../rsc/CSharp.g3:2824:13: ( ( IF )=> IF ( ignoredtail )? )
			// ../rsc/CSharp.g3:2824:15: ( IF )=> IF ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				IF1419 = (Token) match(this.input, IF, FOLLOW_IF_in_iF19916);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					IF1419_tree = (Object) this.adaptor.create(IF1419);
					this.adaptor.addChild(root_0, IF1419_tree);
				}
				// ../rsc/CSharp.g3:2824:26: ( ignoredtail )?
				int alt391 = 2;
				int LA391_0 = this.input.LA(1);

				if (((LA391_0 >= Whitespace && LA391_0 <= Preprocessordirective))) {
					alt391 = 1;
				}
				switch (alt391) {
					case 1 :
					// ../rsc/CSharp.g3:2824:27: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_iF19919);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iF"

	public static class iMPLICIT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iMPLICIT"
	// ../rsc/CSharp.g3:2825:1: iMPLICIT : ( IMPLICIT )=> IMPLICIT ( ignoredtail )? ;
	public final CSharpParser.iMPLICIT_return iMPLICIT()
			throws RecognitionException {
		CSharpParser.iMPLICIT_return retval =
			new CSharpParser.iMPLICIT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token IMPLICIT1421 = null;
		Object IMPLICIT1421_tree = null;

		try {
			// ../rsc/CSharp.g3:2825:13: ( ( IMPLICIT )=> IMPLICIT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2825:15: ( IMPLICIT )=> IMPLICIT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				IMPLICIT1421 =
					(Token) match(
						this.input,
						IMPLICIT,
						FOLLOW_IMPLICIT_in_iMPLICIT19938);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					IMPLICIT1421_tree = (Object) this.adaptor.create(IMPLICIT1421);
					this.adaptor.addChild(root_0, IMPLICIT1421_tree);
				}
				// ../rsc/CSharp.g3:2825:38: ( ignoredtail )?
				int alt392 = 2;
				int LA392_0 = this.input.LA(1);

				if (((LA392_0 >= Whitespace && LA392_0 <= Preprocessordirective))) {
					alt392 = 1;
				}
				switch (alt392) {
					case 1 :
					// ../rsc/CSharp.g3:2825:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_iMPLICIT19941);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iMPLICIT"

	public static class iN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iN"
	// ../rsc/CSharp.g3:2826:1: iN : ( IN )=> IN ( ignoredtail )? ;
	public final CSharpParser.iN_return iN() throws RecognitionException {
		CSharpParser.iN_return retval = new CSharpParser.iN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token IN1423 = null;
		Object IN1423_tree = null;

		try {
			// ../rsc/CSharp.g3:2826:13: ( ( IN )=> IN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2826:15: ( IN )=> IN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				IN1423 = (Token) match(this.input, IN, FOLLOW_IN_in_iN19966);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					IN1423_tree = (Object) this.adaptor.create(IN1423);
					this.adaptor.addChild(root_0, IN1423_tree);
				}
				// ../rsc/CSharp.g3:2826:26: ( ignoredtail )?
				int alt393 = 2;
				int LA393_0 = this.input.LA(1);

				if (((LA393_0 >= Whitespace && LA393_0 <= Preprocessordirective))) {
					alt393 = 1;
				}
				switch (alt393) {
					case 1 :
					// ../rsc/CSharp.g3:2826:27: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_iN19969);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iN"

	public static class iNT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iNT"
	// ../rsc/CSharp.g3:2827:1: iNT : ( INT )=> INT ( ignoredtail )? ;
	public final CSharpParser.iNT_return iNT() throws RecognitionException {
		CSharpParser.iNT_return retval = new CSharpParser.iNT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token INT1425 = null;
		Object INT1425_tree = null;

		try {
			// ../rsc/CSharp.g3:2827:13: ( ( INT )=> INT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2827:15: ( INT )=> INT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				INT1425 = (Token) match(this.input, INT, FOLLOW_INT_in_iNT19993);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					INT1425_tree = (Object) this.adaptor.create(INT1425);
					this.adaptor.addChild(root_0, INT1425_tree);
				}
				// ../rsc/CSharp.g3:2827:28: ( ignoredtail )?
				int alt394 = 2;
				int LA394_0 = this.input.LA(1);

				if (((LA394_0 >= Whitespace && LA394_0 <= Preprocessordirective))) {
					alt394 = 1;
				}
				switch (alt394) {
					case 1 :
					// ../rsc/CSharp.g3:2827:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_iNT19996);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iNT"

	public static class iNTERFACE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iNTERFACE"
	// ../rsc/CSharp.g3:2828:1: iNTERFACE : ( INTERFACE )=> INTERFACE ( ignoredtail )? ;
	public final CSharpParser.iNTERFACE_return iNTERFACE()
			throws RecognitionException {
		CSharpParser.iNTERFACE_return retval =
			new CSharpParser.iNTERFACE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token INTERFACE1427 = null;
		Object INTERFACE1427_tree = null;

		try {
			// ../rsc/CSharp.g3:2828:13: ( ( INTERFACE )=> INTERFACE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2828:15: ( INTERFACE )=> INTERFACE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				INTERFACE1427 =
					(Token) match(
						this.input,
						INTERFACE,
						FOLLOW_INTERFACE_in_iNTERFACE20014);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					INTERFACE1427_tree = (Object) this.adaptor.create(INTERFACE1427);
					this.adaptor.addChild(root_0, INTERFACE1427_tree);
				}
				// ../rsc/CSharp.g3:2828:40: ( ignoredtail )?
				int alt395 = 2;
				int LA395_0 = this.input.LA(1);

				if (((LA395_0 >= Whitespace && LA395_0 <= Preprocessordirective))) {
					alt395 = 1;
				}
				switch (alt395) {
					case 1 :
					// ../rsc/CSharp.g3:2828:41: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_iNTERFACE20017);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iNTERFACE"

	public static class iNTERNAL_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iNTERNAL"
	// ../rsc/CSharp.g3:2829:1: iNTERNAL : ( INTERNAL )=> INTERNAL ( ignoredtail )? ;
	public final CSharpParser.iNTERNAL_return iNTERNAL()
			throws RecognitionException {
		CSharpParser.iNTERNAL_return retval =
			new CSharpParser.iNTERNAL_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token INTERNAL1429 = null;
		Object INTERNAL1429_tree = null;

		try {
			// ../rsc/CSharp.g3:2829:13: ( ( INTERNAL )=> INTERNAL ( ignoredtail )? )
			// ../rsc/CSharp.g3:2829:15: ( INTERNAL )=> INTERNAL ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				INTERNAL1429 =
					(Token) match(
						this.input,
						INTERNAL,
						FOLLOW_INTERNAL_in_iNTERNAL20036);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					INTERNAL1429_tree = (Object) this.adaptor.create(INTERNAL1429);
					this.adaptor.addChild(root_0, INTERNAL1429_tree);
				}
				// ../rsc/CSharp.g3:2829:38: ( ignoredtail )?
				int alt396 = 2;
				int LA396_0 = this.input.LA(1);

				if (((LA396_0 >= Whitespace && LA396_0 <= Preprocessordirective))) {
					alt396 = 1;
				}
				switch (alt396) {
					case 1 :
					// ../rsc/CSharp.g3:2829:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_iNTERNAL20039);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iNTERNAL"

	public static class iS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "iS"
	// ../rsc/CSharp.g3:2830:1: iS : ( IS )=> IS ( ignoredtail )? ;
	public final CSharpParser.iS_return iS() throws RecognitionException {
		CSharpParser.iS_return retval = new CSharpParser.iS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token IS1431 = null;
		Object IS1431_tree = null;

		try {
			// ../rsc/CSharp.g3:2830:13: ( ( IS )=> IS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2830:15: ( IS )=> IS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				IS1431 = (Token) match(this.input, IS, FOLLOW_IS_in_iS20064);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					IS1431_tree = (Object) this.adaptor.create(IS1431);
					this.adaptor.addChild(root_0, IS1431_tree);
				}
				// ../rsc/CSharp.g3:2830:26: ( ignoredtail )?
				int alt397 = 2;
				int LA397_0 = this.input.LA(1);

				if (((LA397_0 >= Whitespace && LA397_0 <= Preprocessordirective))) {
					alt397 = 1;
				}
				switch (alt397) {
					case 1 :
					// ../rsc/CSharp.g3:2830:27: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_iS20067);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "iS"

	public static class lOCK_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lOCK"
	// ../rsc/CSharp.g3:2831:1: lOCK : ( LOCK )=> LOCK ( ignoredtail )? ;
	public final CSharpParser.lOCK_return lOCK() throws RecognitionException {
		CSharpParser.lOCK_return retval = new CSharpParser.lOCK_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LOCK1433 = null;
		Object LOCK1433_tree = null;

		try {
			// ../rsc/CSharp.g3:2831:13: ( ( LOCK )=> LOCK ( ignoredtail )? )
			// ../rsc/CSharp.g3:2831:15: ( LOCK )=> LOCK ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LOCK1433 = (Token) match(this.input, LOCK, FOLLOW_LOCK_in_lOCK20090);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LOCK1433_tree = (Object) this.adaptor.create(LOCK1433);
					this.adaptor.addChild(root_0, LOCK1433_tree);
				}
				// ../rsc/CSharp.g3:2831:30: ( ignoredtail )?
				int alt398 = 2;
				int LA398_0 = this.input.LA(1);

				if (((LA398_0 >= Whitespace && LA398_0 <= Preprocessordirective))) {
					alt398 = 1;
				}
				switch (alt398) {
					case 1 :
					// ../rsc/CSharp.g3:2831:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lOCK20093);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lOCK"

	public static class lONG_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "lONG"
	// ../rsc/CSharp.g3:2832:1: lONG : ( LONG )=> LONG ( ignoredtail )? ;
	public final CSharpParser.lONG_return lONG() throws RecognitionException {
		CSharpParser.lONG_return retval = new CSharpParser.lONG_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token LONG1435 = null;
		Object LONG1435_tree = null;

		try {
			// ../rsc/CSharp.g3:2832:13: ( ( LONG )=> LONG ( ignoredtail )? )
			// ../rsc/CSharp.g3:2832:15: ( LONG )=> LONG ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				LONG1435 = (Token) match(this.input, LONG, FOLLOW_LONG_in_lONG20116);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					LONG1435_tree = (Object) this.adaptor.create(LONG1435);
					this.adaptor.addChild(root_0, LONG1435_tree);
				}
				// ../rsc/CSharp.g3:2832:30: ( ignoredtail )?
				int alt399 = 2;
				int LA399_0 = this.input.LA(1);

				if (((LA399_0 >= Whitespace && LA399_0 <= Preprocessordirective))) {
					alt399 = 1;
				}
				switch (alt399) {
					case 1 :
					// ../rsc/CSharp.g3:2832:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_lONG20119);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "lONG"

	public static class nAMESPACE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "nAMESPACE"
	// ../rsc/CSharp.g3:2833:1: nAMESPACE : ( NAMESPACE )=> NAMESPACE ( ignoredtail )? ;
	public final CSharpParser.nAMESPACE_return nAMESPACE()
			throws RecognitionException {
		CSharpParser.nAMESPACE_return retval =
			new CSharpParser.nAMESPACE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token NAMESPACE1437 = null;
		Object NAMESPACE1437_tree = null;

		try {
			// ../rsc/CSharp.g3:2833:13: ( ( NAMESPACE )=> NAMESPACE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2833:15: ( NAMESPACE )=> NAMESPACE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				NAMESPACE1437 =
					(Token) match(
						this.input,
						NAMESPACE,
						FOLLOW_NAMESPACE_in_nAMESPACE20137);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					NAMESPACE1437_tree = (Object) this.adaptor.create(NAMESPACE1437);
					this.adaptor.addChild(root_0, NAMESPACE1437_tree);
				}
				// ../rsc/CSharp.g3:2833:40: ( ignoredtail )?
				int alt400 = 2;
				int LA400_0 = this.input.LA(1);

				if (((LA400_0 >= Whitespace && LA400_0 <= Preprocessordirective))) {
					alt400 = 1;
				}
				switch (alt400) {
					case 1 :
					// ../rsc/CSharp.g3:2833:41: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_nAMESPACE20140);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "nAMESPACE"

	public static class nEW_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "nEW"
	// ../rsc/CSharp.g3:2834:1: nEW : ( NEW )=> NEW ( ignoredtail )? ;
	public final CSharpParser.nEW_return nEW() throws RecognitionException {
		CSharpParser.nEW_return retval = new CSharpParser.nEW_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token NEW1439 = null;
		Object NEW1439_tree = null;

		try {
			// ../rsc/CSharp.g3:2834:13: ( ( NEW )=> NEW ( ignoredtail )? )
			// ../rsc/CSharp.g3:2834:15: ( NEW )=> NEW ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				NEW1439 = (Token) match(this.input, NEW, FOLLOW_NEW_in_nEW20164);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					NEW1439_tree = (Object) this.adaptor.create(NEW1439);
					this.adaptor.addChild(root_0, NEW1439_tree);
				}
				// ../rsc/CSharp.g3:2834:28: ( ignoredtail )?
				int alt401 = 2;
				int LA401_0 = this.input.LA(1);

				if (((LA401_0 >= Whitespace && LA401_0 <= Preprocessordirective))) {
					alt401 = 1;
				}
				switch (alt401) {
					case 1 :
					// ../rsc/CSharp.g3:2834:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_nEW20167);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "nEW"

	public static class nULL_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "nULL"
	// ../rsc/CSharp.g3:2835:1: nULL : ( NULL )=> NULL ( ignoredtail )? ;
	public final CSharpParser.nULL_return nULL() throws RecognitionException {
		CSharpParser.nULL_return retval = new CSharpParser.nULL_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token NULL1441 = null;
		Object NULL1441_tree = null;

		try {
			// ../rsc/CSharp.g3:2835:13: ( ( NULL )=> NULL ( ignoredtail )? )
			// ../rsc/CSharp.g3:2835:15: ( NULL )=> NULL ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				NULL1441 = (Token) match(this.input, NULL, FOLLOW_NULL_in_nULL20190);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					NULL1441_tree = (Object) this.adaptor.create(NULL1441);
					this.adaptor.addChild(root_0, NULL1441_tree);
				}
				// ../rsc/CSharp.g3:2835:30: ( ignoredtail )?
				int alt402 = 2;
				int LA402_0 = this.input.LA(1);

				if (((LA402_0 >= Whitespace && LA402_0 <= Preprocessordirective))) {
					alt402 = 1;
				}
				switch (alt402) {
					case 1 :
					// ../rsc/CSharp.g3:2835:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_nULL20193);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "nULL"

	public static class oBJECT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "oBJECT"
	// ../rsc/CSharp.g3:2836:1: oBJECT : ( OBJECT )=> OBJECT ( ignoredtail )? ;
	public final CSharpParser.oBJECT_return oBJECT()
			throws RecognitionException {
		CSharpParser.oBJECT_return retval = new CSharpParser.oBJECT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token OBJECT1443 = null;
		Object OBJECT1443_tree = null;

		try {
			// ../rsc/CSharp.g3:2836:13: ( ( OBJECT )=> OBJECT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2836:15: ( OBJECT )=> OBJECT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				OBJECT1443 =
					(Token) match(this.input, OBJECT, FOLLOW_OBJECT_in_oBJECT20214);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					OBJECT1443_tree = (Object) this.adaptor.create(OBJECT1443);
					this.adaptor.addChild(root_0, OBJECT1443_tree);
				}
				// ../rsc/CSharp.g3:2836:34: ( ignoredtail )?
				int alt403 = 2;
				int LA403_0 = this.input.LA(1);

				if (((LA403_0 >= Whitespace && LA403_0 <= Preprocessordirective))) {
					alt403 = 1;
				}
				switch (alt403) {
					case 1 :
					// ../rsc/CSharp.g3:2836:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_oBJECT20217);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "oBJECT"

	public static class oPERATOR_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "oPERATOR"
	// ../rsc/CSharp.g3:2837:1: oPERATOR : ( OPERATOR )=> OPERATOR ( ignoredtail )? ;
	public final CSharpParser.oPERATOR_return oPERATOR()
			throws RecognitionException {
		CSharpParser.oPERATOR_return retval =
			new CSharpParser.oPERATOR_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token OPERATOR1445 = null;
		Object OPERATOR1445_tree = null;

		try {
			// ../rsc/CSharp.g3:2837:13: ( ( OPERATOR )=> OPERATOR ( ignoredtail )? )
			// ../rsc/CSharp.g3:2837:15: ( OPERATOR )=> OPERATOR ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				OPERATOR1445 =
					(Token) match(
						this.input,
						OPERATOR,
						FOLLOW_OPERATOR_in_oPERATOR20236);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					OPERATOR1445_tree = (Object) this.adaptor.create(OPERATOR1445);
					this.adaptor.addChild(root_0, OPERATOR1445_tree);
				}
				// ../rsc/CSharp.g3:2837:38: ( ignoredtail )?
				int alt404 = 2;
				int LA404_0 = this.input.LA(1);

				if (((LA404_0 >= Whitespace && LA404_0 <= Preprocessordirective))) {
					alt404 = 1;
				}
				switch (alt404) {
					case 1 :
					// ../rsc/CSharp.g3:2837:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_oPERATOR20239);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "oPERATOR"

	public static class oUT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "oUT"
	// ../rsc/CSharp.g3:2838:1: oUT : ( OUT )=> OUT ( ignoredtail )? ;
	public final CSharpParser.oUT_return oUT() throws RecognitionException {
		CSharpParser.oUT_return retval = new CSharpParser.oUT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token OUT1447 = null;
		Object OUT1447_tree = null;

		try {
			// ../rsc/CSharp.g3:2838:13: ( ( OUT )=> OUT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2838:15: ( OUT )=> OUT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				OUT1447 = (Token) match(this.input, OUT, FOLLOW_OUT_in_oUT20263);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					OUT1447_tree = (Object) this.adaptor.create(OUT1447);
					this.adaptor.addChild(root_0, OUT1447_tree);
				}
				// ../rsc/CSharp.g3:2838:28: ( ignoredtail )?
				int alt405 = 2;
				int LA405_0 = this.input.LA(1);

				if (((LA405_0 >= Whitespace && LA405_0 <= Preprocessordirective))) {
					alt405 = 1;
				}
				switch (alt405) {
					case 1 :
					// ../rsc/CSharp.g3:2838:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_oUT20266);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "oUT"

	public static class oVERRIDE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "oVERRIDE"
	// ../rsc/CSharp.g3:2839:1: oVERRIDE : ( OVERRIDE )=> OVERRIDE ( ignoredtail )? ;
	public final CSharpParser.oVERRIDE_return oVERRIDE()
			throws RecognitionException {
		CSharpParser.oVERRIDE_return retval =
			new CSharpParser.oVERRIDE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token OVERRIDE1449 = null;
		Object OVERRIDE1449_tree = null;

		try {
			// ../rsc/CSharp.g3:2839:13: ( ( OVERRIDE )=> OVERRIDE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2839:15: ( OVERRIDE )=> OVERRIDE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				OVERRIDE1449 =
					(Token) match(
						this.input,
						OVERRIDE,
						FOLLOW_OVERRIDE_in_oVERRIDE20285);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					OVERRIDE1449_tree = (Object) this.adaptor.create(OVERRIDE1449);
					this.adaptor.addChild(root_0, OVERRIDE1449_tree);
				}
				// ../rsc/CSharp.g3:2839:38: ( ignoredtail )?
				int alt406 = 2;
				int LA406_0 = this.input.LA(1);

				if (((LA406_0 >= Whitespace && LA406_0 <= Preprocessordirective))) {
					alt406 = 1;
				}
				switch (alt406) {
					case 1 :
					// ../rsc/CSharp.g3:2839:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_oVERRIDE20288);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "oVERRIDE"

	public static class pARAMS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "pARAMS"
	// ../rsc/CSharp.g3:2840:1: pARAMS : ( PARAMS )=> PARAMS ( ignoredtail )? ;
	public final CSharpParser.pARAMS_return pARAMS()
			throws RecognitionException {
		CSharpParser.pARAMS_return retval = new CSharpParser.pARAMS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token PARAMS1451 = null;
		Object PARAMS1451_tree = null;

		try {
			// ../rsc/CSharp.g3:2840:13: ( ( PARAMS )=> PARAMS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2840:15: ( PARAMS )=> PARAMS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				PARAMS1451 =
					(Token) match(this.input, PARAMS, FOLLOW_PARAMS_in_pARAMS20309);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					PARAMS1451_tree = (Object) this.adaptor.create(PARAMS1451);
					this.adaptor.addChild(root_0, PARAMS1451_tree);
				}
				// ../rsc/CSharp.g3:2840:34: ( ignoredtail )?
				int alt407 = 2;
				int LA407_0 = this.input.LA(1);

				if (((LA407_0 >= Whitespace && LA407_0 <= Preprocessordirective))) {
					alt407 = 1;
				}
				switch (alt407) {
					case 1 :
					// ../rsc/CSharp.g3:2840:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_pARAMS20312);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "pARAMS"

	public static class pRIVATE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "pRIVATE"
	// ../rsc/CSharp.g3:2841:1: pRIVATE : ( PRIVATE )=> PRIVATE ( ignoredtail )? ;
	public final CSharpParser.pRIVATE_return pRIVATE()
			throws RecognitionException {
		CSharpParser.pRIVATE_return retval = new CSharpParser.pRIVATE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token PRIVATE1453 = null;
		Object PRIVATE1453_tree = null;

		try {
			// ../rsc/CSharp.g3:2841:13: ( ( PRIVATE )=> PRIVATE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2841:15: ( PRIVATE )=> PRIVATE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				PRIVATE1453 =
					(Token) match(
						this.input,
						PRIVATE,
						FOLLOW_PRIVATE_in_pRIVATE20332);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					PRIVATE1453_tree = (Object) this.adaptor.create(PRIVATE1453);
					this.adaptor.addChild(root_0, PRIVATE1453_tree);
				}
				// ../rsc/CSharp.g3:2841:36: ( ignoredtail )?
				int alt408 = 2;
				int LA408_0 = this.input.LA(1);

				if (((LA408_0 >= Whitespace && LA408_0 <= Preprocessordirective))) {
					alt408 = 1;
				}
				switch (alt408) {
					case 1 :
					// ../rsc/CSharp.g3:2841:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_pRIVATE20335);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "pRIVATE"

	public static class pROTECTED_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "pROTECTED"
	// ../rsc/CSharp.g3:2842:1: pROTECTED : ( PROTECTED )=> PROTECTED ( ignoredtail )? ;
	public final CSharpParser.pROTECTED_return pROTECTED()
			throws RecognitionException {
		CSharpParser.pROTECTED_return retval =
			new CSharpParser.pROTECTED_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token PROTECTED1455 = null;
		Object PROTECTED1455_tree = null;

		try {
			// ../rsc/CSharp.g3:2842:13: ( ( PROTECTED )=> PROTECTED ( ignoredtail )? )
			// ../rsc/CSharp.g3:2842:15: ( PROTECTED )=> PROTECTED ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				PROTECTED1455 =
					(Token) match(
						this.input,
						PROTECTED,
						FOLLOW_PROTECTED_in_pROTECTED20353);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					PROTECTED1455_tree = (Object) this.adaptor.create(PROTECTED1455);
					this.adaptor.addChild(root_0, PROTECTED1455_tree);
				}
				// ../rsc/CSharp.g3:2842:40: ( ignoredtail )?
				int alt409 = 2;
				int LA409_0 = this.input.LA(1);

				if (((LA409_0 >= Whitespace && LA409_0 <= Preprocessordirective))) {
					alt409 = 1;
				}
				switch (alt409) {
					case 1 :
					// ../rsc/CSharp.g3:2842:41: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_pROTECTED20356);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "pROTECTED"

	public static class pUBLIC_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "pUBLIC"
	// ../rsc/CSharp.g3:2843:1: pUBLIC : ( PUBLIC )=> PUBLIC ( ignoredtail )? ;
	public final CSharpParser.pUBLIC_return pUBLIC()
			throws RecognitionException {
		CSharpParser.pUBLIC_return retval = new CSharpParser.pUBLIC_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token PUBLIC1457 = null;
		Object PUBLIC1457_tree = null;

		try {
			// ../rsc/CSharp.g3:2843:13: ( ( PUBLIC )=> PUBLIC ( ignoredtail )? )
			// ../rsc/CSharp.g3:2843:15: ( PUBLIC )=> PUBLIC ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				PUBLIC1457 =
					(Token) match(this.input, PUBLIC, FOLLOW_PUBLIC_in_pUBLIC20377);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					PUBLIC1457_tree = (Object) this.adaptor.create(PUBLIC1457);
					this.adaptor.addChild(root_0, PUBLIC1457_tree);
				}
				// ../rsc/CSharp.g3:2843:34: ( ignoredtail )?
				int alt410 = 2;
				int LA410_0 = this.input.LA(1);

				if (((LA410_0 >= Whitespace && LA410_0 <= Preprocessordirective))) {
					alt410 = 1;
				}
				switch (alt410) {
					case 1 :
					// ../rsc/CSharp.g3:2843:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_pUBLIC20380);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "pUBLIC"

	public static class rEADONLY_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rEADONLY"
	// ../rsc/CSharp.g3:2844:1: rEADONLY : ( READONLY )=> READONLY ( ignoredtail )? ;
	public final CSharpParser.rEADONLY_return rEADONLY()
			throws RecognitionException {
		CSharpParser.rEADONLY_return retval =
			new CSharpParser.rEADONLY_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token READONLY1459 = null;
		Object READONLY1459_tree = null;

		try {
			// ../rsc/CSharp.g3:2844:13: ( ( READONLY )=> READONLY ( ignoredtail )? )
			// ../rsc/CSharp.g3:2844:15: ( READONLY )=> READONLY ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				READONLY1459 =
					(Token) match(
						this.input,
						READONLY,
						FOLLOW_READONLY_in_rEADONLY20399);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					READONLY1459_tree = (Object) this.adaptor.create(READONLY1459);
					this.adaptor.addChild(root_0, READONLY1459_tree);
				}
				// ../rsc/CSharp.g3:2844:38: ( ignoredtail )?
				int alt411 = 2;
				int LA411_0 = this.input.LA(1);

				if (((LA411_0 >= Whitespace && LA411_0 <= Preprocessordirective))) {
					alt411 = 1;
				}
				switch (alt411) {
					case 1 :
					// ../rsc/CSharp.g3:2844:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rEADONLY20402);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rEADONLY"

	public static class rEF_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rEF"
	// ../rsc/CSharp.g3:2845:1: rEF : ( REF )=> REF ( ignoredtail )? ;
	public final CSharpParser.rEF_return rEF() throws RecognitionException {
		CSharpParser.rEF_return retval = new CSharpParser.rEF_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token REF1461 = null;
		Object REF1461_tree = null;

		try {
			// ../rsc/CSharp.g3:2845:13: ( ( REF )=> REF ( ignoredtail )? )
			// ../rsc/CSharp.g3:2845:15: ( REF )=> REF ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				REF1461 = (Token) match(this.input, REF, FOLLOW_REF_in_rEF20426);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					REF1461_tree = (Object) this.adaptor.create(REF1461);
					this.adaptor.addChild(root_0, REF1461_tree);
				}
				// ../rsc/CSharp.g3:2845:28: ( ignoredtail )?
				int alt412 = 2;
				int LA412_0 = this.input.LA(1);

				if (((LA412_0 >= Whitespace && LA412_0 <= Preprocessordirective))) {
					alt412 = 1;
				}
				switch (alt412) {
					case 1 :
					// ../rsc/CSharp.g3:2845:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rEF20429);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rEF"

	public static class rETURN_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rETURN"
	// ../rsc/CSharp.g3:2846:1: rETURN : ( RETURN )=> RETURN ( ignoredtail )? ;
	public final CSharpParser.rETURN_return rETURN()
			throws RecognitionException {
		CSharpParser.rETURN_return retval = new CSharpParser.rETURN_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token RETURN1463 = null;
		Object RETURN1463_tree = null;

		try {
			// ../rsc/CSharp.g3:2846:13: ( ( RETURN )=> RETURN ( ignoredtail )? )
			// ../rsc/CSharp.g3:2846:15: ( RETURN )=> RETURN ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				RETURN1463 =
					(Token) match(this.input, RETURN, FOLLOW_RETURN_in_rETURN20450);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					RETURN1463_tree = (Object) this.adaptor.create(RETURN1463);
					this.adaptor.addChild(root_0, RETURN1463_tree);
				}
				// ../rsc/CSharp.g3:2846:34: ( ignoredtail )?
				int alt413 = 2;
				int LA413_0 = this.input.LA(1);

				if (((LA413_0 >= Whitespace && LA413_0 <= Preprocessordirective))) {
					alt413 = 1;
				}
				switch (alt413) {
					case 1 :
					// ../rsc/CSharp.g3:2846:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rETURN20453);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rETURN"

	public static class sBYTE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sBYTE"
	// ../rsc/CSharp.g3:2847:1: sBYTE : ( SBYTE )=> SBYTE ( ignoredtail )? ;
	public final CSharpParser.sBYTE_return sBYTE() throws RecognitionException {
		CSharpParser.sBYTE_return retval = new CSharpParser.sBYTE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token SBYTE1465 = null;
		Object SBYTE1465_tree = null;

		try {
			// ../rsc/CSharp.g3:2847:13: ( ( SBYTE )=> SBYTE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2847:15: ( SBYTE )=> SBYTE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				SBYTE1465 =
					(Token) match(this.input, SBYTE, FOLLOW_SBYTE_in_sBYTE20475);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					SBYTE1465_tree = (Object) this.adaptor.create(SBYTE1465);
					this.adaptor.addChild(root_0, SBYTE1465_tree);
				}
				// ../rsc/CSharp.g3:2847:32: ( ignoredtail )?
				int alt414 = 2;
				int LA414_0 = this.input.LA(1);

				if (((LA414_0 >= Whitespace && LA414_0 <= Preprocessordirective))) {
					alt414 = 1;
				}
				switch (alt414) {
					case 1 :
					// ../rsc/CSharp.g3:2847:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sBYTE20478);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sBYTE"

	public static class sEALED_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sEALED"
	// ../rsc/CSharp.g3:2848:1: sEALED : ( SEALED )=> SEALED ( ignoredtail )? ;
	public final CSharpParser.sEALED_return sEALED()
			throws RecognitionException {
		CSharpParser.sEALED_return retval = new CSharpParser.sEALED_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token SEALED1467 = null;
		Object SEALED1467_tree = null;

		try {
			// ../rsc/CSharp.g3:2848:13: ( ( SEALED )=> SEALED ( ignoredtail )? )
			// ../rsc/CSharp.g3:2848:15: ( SEALED )=> SEALED ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				SEALED1467 =
					(Token) match(this.input, SEALED, FOLLOW_SEALED_in_sEALED20499);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					SEALED1467_tree = (Object) this.adaptor.create(SEALED1467);
					this.adaptor.addChild(root_0, SEALED1467_tree);
				}
				// ../rsc/CSharp.g3:2848:34: ( ignoredtail )?
				int alt415 = 2;
				int LA415_0 = this.input.LA(1);

				if (((LA415_0 >= Whitespace && LA415_0 <= Preprocessordirective))) {
					alt415 = 1;
				}
				switch (alt415) {
					case 1 :
					// ../rsc/CSharp.g3:2848:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sEALED20502);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sEALED"

	public static class sHORT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sHORT"
	// ../rsc/CSharp.g3:2849:1: sHORT : ( SHORT )=> SHORT ( ignoredtail )? ;
	public final CSharpParser.sHORT_return sHORT() throws RecognitionException {
		CSharpParser.sHORT_return retval = new CSharpParser.sHORT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token SHORT1469 = null;
		Object SHORT1469_tree = null;

		try {
			// ../rsc/CSharp.g3:2849:13: ( ( SHORT )=> SHORT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2849:15: ( SHORT )=> SHORT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				SHORT1469 =
					(Token) match(this.input, SHORT, FOLLOW_SHORT_in_sHORT20524);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					SHORT1469_tree = (Object) this.adaptor.create(SHORT1469);
					this.adaptor.addChild(root_0, SHORT1469_tree);
				}
				// ../rsc/CSharp.g3:2849:32: ( ignoredtail )?
				int alt416 = 2;
				int LA416_0 = this.input.LA(1);

				if (((LA416_0 >= Whitespace && LA416_0 <= Preprocessordirective))) {
					alt416 = 1;
				}
				switch (alt416) {
					case 1 :
					// ../rsc/CSharp.g3:2849:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sHORT20527);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sHORT"

	public static class sIZEOF_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sIZEOF"
	// ../rsc/CSharp.g3:2850:1: sIZEOF : ( SIZEOF )=> SIZEOF ( ignoredtail )? ;
	public final CSharpParser.sIZEOF_return sIZEOF()
			throws RecognitionException {
		CSharpParser.sIZEOF_return retval = new CSharpParser.sIZEOF_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token SIZEOF1471 = null;
		Object SIZEOF1471_tree = null;

		try {
			// ../rsc/CSharp.g3:2850:13: ( ( SIZEOF )=> SIZEOF ( ignoredtail )? )
			// ../rsc/CSharp.g3:2850:15: ( SIZEOF )=> SIZEOF ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				SIZEOF1471 =
					(Token) match(this.input, SIZEOF, FOLLOW_SIZEOF_in_sIZEOF20548);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					SIZEOF1471_tree = (Object) this.adaptor.create(SIZEOF1471);
					this.adaptor.addChild(root_0, SIZEOF1471_tree);
				}
				// ../rsc/CSharp.g3:2850:34: ( ignoredtail )?
				int alt417 = 2;
				int LA417_0 = this.input.LA(1);

				if (((LA417_0 >= Whitespace && LA417_0 <= Preprocessordirective))) {
					alt417 = 1;
				}
				switch (alt417) {
					case 1 :
					// ../rsc/CSharp.g3:2850:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sIZEOF20551);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sIZEOF"

	public static class sTACKALLOC_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sTACKALLOC"
	// ../rsc/CSharp.g3:2851:1: sTACKALLOC : ( STACKALLOC )=> STACKALLOC ( ignoredtail )? ;
	public final CSharpParser.sTACKALLOC_return sTACKALLOC()
			throws RecognitionException {
		CSharpParser.sTACKALLOC_return retval =
			new CSharpParser.sTACKALLOC_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token STACKALLOC1473 = null;
		Object STACKALLOC1473_tree = null;

		try {
			// ../rsc/CSharp.g3:2851:13: ( ( STACKALLOC )=> STACKALLOC ( ignoredtail )? )
			// ../rsc/CSharp.g3:2851:15: ( STACKALLOC )=> STACKALLOC ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				STACKALLOC1473 =
					(Token) match(
						this.input,
						STACKALLOC,
						FOLLOW_STACKALLOC_in_sTACKALLOC20568);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					STACKALLOC1473_tree =
						(Object) this.adaptor.create(STACKALLOC1473);
					this.adaptor.addChild(root_0, STACKALLOC1473_tree);
				}
				// ../rsc/CSharp.g3:2851:42: ( ignoredtail )?
				int alt418 = 2;
				int LA418_0 = this.input.LA(1);

				if (((LA418_0 >= Whitespace && LA418_0 <= Preprocessordirective))) {
					alt418 = 1;
				}
				switch (alt418) {
					case 1 :
					// ../rsc/CSharp.g3:2851:43: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sTACKALLOC20571);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sTACKALLOC"

	public static class sTATIC_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sTATIC"
	// ../rsc/CSharp.g3:2852:1: sTATIC : ( STATIC )=> STATIC ( ignoredtail )? ;
	public final CSharpParser.sTATIC_return sTATIC()
			throws RecognitionException {
		CSharpParser.sTATIC_return retval = new CSharpParser.sTATIC_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token STATIC1475 = null;
		Object STATIC1475_tree = null;

		try {
			// ../rsc/CSharp.g3:2852:13: ( ( STATIC )=> STATIC ( ignoredtail )? )
			// ../rsc/CSharp.g3:2852:15: ( STATIC )=> STATIC ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				STATIC1475 =
					(Token) match(this.input, STATIC, FOLLOW_STATIC_in_sTATIC20592);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					STATIC1475_tree = (Object) this.adaptor.create(STATIC1475);
					this.adaptor.addChild(root_0, STATIC1475_tree);
				}
				// ../rsc/CSharp.g3:2852:34: ( ignoredtail )?
				int alt419 = 2;
				int LA419_0 = this.input.LA(1);

				if (((LA419_0 >= Whitespace && LA419_0 <= Preprocessordirective))) {
					alt419 = 1;
				}
				switch (alt419) {
					case 1 :
					// ../rsc/CSharp.g3:2852:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sTATIC20595);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sTATIC"

	public static class sTRING_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sTRING"
	// ../rsc/CSharp.g3:2853:1: sTRING : ( STRING )=> STRING ( ignoredtail )? ;
	public final CSharpParser.sTRING_return sTRING()
			throws RecognitionException {
		CSharpParser.sTRING_return retval = new CSharpParser.sTRING_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token STRING1477 = null;
		Object STRING1477_tree = null;

		try {
			// ../rsc/CSharp.g3:2853:13: ( ( STRING )=> STRING ( ignoredtail )? )
			// ../rsc/CSharp.g3:2853:15: ( STRING )=> STRING ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				STRING1477 =
					(Token) match(this.input, STRING, FOLLOW_STRING_in_sTRING20616);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					STRING1477_tree = (Object) this.adaptor.create(STRING1477);
					this.adaptor.addChild(root_0, STRING1477_tree);
				}
				// ../rsc/CSharp.g3:2853:34: ( ignoredtail )?
				int alt420 = 2;
				int LA420_0 = this.input.LA(1);

				if (((LA420_0 >= Whitespace && LA420_0 <= Preprocessordirective))) {
					alt420 = 1;
				}
				switch (alt420) {
					case 1 :
					// ../rsc/CSharp.g3:2853:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sTRING20619);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sTRING"

	public static class sTRUCT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sTRUCT"
	// ../rsc/CSharp.g3:2854:1: sTRUCT : ( STRUCT )=> STRUCT ( ignoredtail )? ;
	public final CSharpParser.sTRUCT_return sTRUCT()
			throws RecognitionException {
		CSharpParser.sTRUCT_return retval = new CSharpParser.sTRUCT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token STRUCT1479 = null;
		Object STRUCT1479_tree = null;

		try {
			// ../rsc/CSharp.g3:2854:13: ( ( STRUCT )=> STRUCT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2854:15: ( STRUCT )=> STRUCT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				STRUCT1479 =
					(Token) match(this.input, STRUCT, FOLLOW_STRUCT_in_sTRUCT20640);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					STRUCT1479_tree = (Object) this.adaptor.create(STRUCT1479);
					this.adaptor.addChild(root_0, STRUCT1479_tree);
				}
				// ../rsc/CSharp.g3:2854:34: ( ignoredtail )?
				int alt421 = 2;
				int LA421_0 = this.input.LA(1);

				if (((LA421_0 >= Whitespace && LA421_0 <= Preprocessordirective))) {
					alt421 = 1;
				}
				switch (alt421) {
					case 1 :
					// ../rsc/CSharp.g3:2854:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sTRUCT20643);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sTRUCT"

	public static class sWITCH_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sWITCH"
	// ../rsc/CSharp.g3:2855:1: sWITCH : ( SWITCH )=> SWITCH ( ignoredtail )? ;
	public final CSharpParser.sWITCH_return sWITCH()
			throws RecognitionException {
		CSharpParser.sWITCH_return retval = new CSharpParser.sWITCH_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token SWITCH1481 = null;
		Object SWITCH1481_tree = null;

		try {
			// ../rsc/CSharp.g3:2855:13: ( ( SWITCH )=> SWITCH ( ignoredtail )? )
			// ../rsc/CSharp.g3:2855:15: ( SWITCH )=> SWITCH ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				SWITCH1481 =
					(Token) match(this.input, SWITCH, FOLLOW_SWITCH_in_sWITCH20664);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					SWITCH1481_tree = (Object) this.adaptor.create(SWITCH1481);
					this.adaptor.addChild(root_0, SWITCH1481_tree);
				}
				// ../rsc/CSharp.g3:2855:34: ( ignoredtail )?
				int alt422 = 2;
				int LA422_0 = this.input.LA(1);

				if (((LA422_0 >= Whitespace && LA422_0 <= Preprocessordirective))) {
					alt422 = 1;
				}
				switch (alt422) {
					case 1 :
					// ../rsc/CSharp.g3:2855:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sWITCH20667);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sWITCH"

	public static class tHIS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "tHIS"
	// ../rsc/CSharp.g3:2856:1: tHIS : ( THIS )=> THIS ( ignoredtail )? ;
	public final CSharpParser.tHIS_return tHIS() throws RecognitionException {
		CSharpParser.tHIS_return retval = new CSharpParser.tHIS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token THIS1483 = null;
		Object THIS1483_tree = null;

		try {
			// ../rsc/CSharp.g3:2856:13: ( ( THIS )=> THIS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2856:15: ( THIS )=> THIS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				THIS1483 = (Token) match(this.input, THIS, FOLLOW_THIS_in_tHIS20690);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					THIS1483_tree = (Object) this.adaptor.create(THIS1483);
					this.adaptor.addChild(root_0, THIS1483_tree);
				}
				// ../rsc/CSharp.g3:2856:30: ( ignoredtail )?
				int alt423 = 2;
				int LA423_0 = this.input.LA(1);

				if (((LA423_0 >= Whitespace && LA423_0 <= Preprocessordirective))) {
					alt423 = 1;
				}
				switch (alt423) {
					case 1 :
					// ../rsc/CSharp.g3:2856:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_tHIS20693);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "tHIS"

	public static class tHROW_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "tHROW"
	// ../rsc/CSharp.g3:2857:1: tHROW : ( THROW )=> THROW ( ignoredtail )? ;
	public final CSharpParser.tHROW_return tHROW() throws RecognitionException {
		CSharpParser.tHROW_return retval = new CSharpParser.tHROW_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token THROW1485 = null;
		Object THROW1485_tree = null;

		try {
			// ../rsc/CSharp.g3:2857:13: ( ( THROW )=> THROW ( ignoredtail )? )
			// ../rsc/CSharp.g3:2857:15: ( THROW )=> THROW ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				THROW1485 =
					(Token) match(this.input, THROW, FOLLOW_THROW_in_tHROW20715);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					THROW1485_tree = (Object) this.adaptor.create(THROW1485);
					this.adaptor.addChild(root_0, THROW1485_tree);
				}
				// ../rsc/CSharp.g3:2857:32: ( ignoredtail )?
				int alt424 = 2;
				int LA424_0 = this.input.LA(1);

				if (((LA424_0 >= Whitespace && LA424_0 <= Preprocessordirective))) {
					alt424 = 1;
				}
				switch (alt424) {
					case 1 :
					// ../rsc/CSharp.g3:2857:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_tHROW20718);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "tHROW"

	public static class tRUE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "tRUE"
	// ../rsc/CSharp.g3:2858:1: tRUE : ( TRUE )=> TRUE ( ignoredtail )? ;
	public final CSharpParser.tRUE_return tRUE() throws RecognitionException {
		CSharpParser.tRUE_return retval = new CSharpParser.tRUE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token TRUE1487 = null;
		Object TRUE1487_tree = null;

		try {
			// ../rsc/CSharp.g3:2858:13: ( ( TRUE )=> TRUE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2858:15: ( TRUE )=> TRUE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				TRUE1487 = (Token) match(this.input, TRUE, FOLLOW_TRUE_in_tRUE20741);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					TRUE1487_tree = (Object) this.adaptor.create(TRUE1487);
					this.adaptor.addChild(root_0, TRUE1487_tree);
				}
				// ../rsc/CSharp.g3:2858:30: ( ignoredtail )?
				int alt425 = 2;
				int LA425_0 = this.input.LA(1);

				if (((LA425_0 >= Whitespace && LA425_0 <= Preprocessordirective))) {
					alt425 = 1;
				}
				switch (alt425) {
					case 1 :
					// ../rsc/CSharp.g3:2858:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_tRUE20744);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "tRUE"

	public static class tRY_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "tRY"
	// ../rsc/CSharp.g3:2859:1: tRY : ( TRY )=> TRY ( ignoredtail )? ;
	public final CSharpParser.tRY_return tRY() throws RecognitionException {
		CSharpParser.tRY_return retval = new CSharpParser.tRY_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token TRY1489 = null;
		Object TRY1489_tree = null;

		try {
			// ../rsc/CSharp.g3:2859:13: ( ( TRY )=> TRY ( ignoredtail )? )
			// ../rsc/CSharp.g3:2859:15: ( TRY )=> TRY ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				TRY1489 = (Token) match(this.input, TRY, FOLLOW_TRY_in_tRY20768);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					TRY1489_tree = (Object) this.adaptor.create(TRY1489);
					this.adaptor.addChild(root_0, TRY1489_tree);
				}
				// ../rsc/CSharp.g3:2859:28: ( ignoredtail )?
				int alt426 = 2;
				int LA426_0 = this.input.LA(1);

				if (((LA426_0 >= Whitespace && LA426_0 <= Preprocessordirective))) {
					alt426 = 1;
				}
				switch (alt426) {
					case 1 :
					// ../rsc/CSharp.g3:2859:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_tRY20771);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "tRY"

	public static class tYPEOF_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "tYPEOF"
	// ../rsc/CSharp.g3:2860:1: tYPEOF : ( TYPEOF )=> TYPEOF ( ignoredtail )? ;
	public final CSharpParser.tYPEOF_return tYPEOF()
			throws RecognitionException {
		CSharpParser.tYPEOF_return retval = new CSharpParser.tYPEOF_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token TYPEOF1491 = null;
		Object TYPEOF1491_tree = null;

		try {
			// ../rsc/CSharp.g3:2860:13: ( ( TYPEOF )=> TYPEOF ( ignoredtail )? )
			// ../rsc/CSharp.g3:2860:15: ( TYPEOF )=> TYPEOF ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				TYPEOF1491 =
					(Token) match(this.input, TYPEOF, FOLLOW_TYPEOF_in_tYPEOF20792);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					TYPEOF1491_tree = (Object) this.adaptor.create(TYPEOF1491);
					this.adaptor.addChild(root_0, TYPEOF1491_tree);
				}
				// ../rsc/CSharp.g3:2860:34: ( ignoredtail )?
				int alt427 = 2;
				int LA427_0 = this.input.LA(1);

				if (((LA427_0 >= Whitespace && LA427_0 <= Preprocessordirective))) {
					alt427 = 1;
				}
				switch (alt427) {
					case 1 :
					// ../rsc/CSharp.g3:2860:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_tYPEOF20795);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "tYPEOF"

	public static class uINT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "uINT"
	// ../rsc/CSharp.g3:2861:1: uINT : ( UINT )=> UINT ( ignoredtail )? ;
	public final CSharpParser.uINT_return uINT() throws RecognitionException {
		CSharpParser.uINT_return retval = new CSharpParser.uINT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token UINT1493 = null;
		Object UINT1493_tree = null;

		try {
			// ../rsc/CSharp.g3:2861:13: ( ( UINT )=> UINT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2861:15: ( UINT )=> UINT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				UINT1493 = (Token) match(this.input, UINT, FOLLOW_UINT_in_uINT20818);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					UINT1493_tree = (Object) this.adaptor.create(UINT1493);
					this.adaptor.addChild(root_0, UINT1493_tree);
				}
				// ../rsc/CSharp.g3:2861:30: ( ignoredtail )?
				int alt428 = 2;
				int LA428_0 = this.input.LA(1);

				if (((LA428_0 >= Whitespace && LA428_0 <= Preprocessordirective))) {
					alt428 = 1;
				}
				switch (alt428) {
					case 1 :
					// ../rsc/CSharp.g3:2861:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_uINT20821);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "uINT"

	public static class uLONG_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "uLONG"
	// ../rsc/CSharp.g3:2862:1: uLONG : ( ULONG )=> ULONG ( ignoredtail )? ;
	public final CSharpParser.uLONG_return uLONG() throws RecognitionException {
		CSharpParser.uLONG_return retval = new CSharpParser.uLONG_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ULONG1495 = null;
		Object ULONG1495_tree = null;

		try {
			// ../rsc/CSharp.g3:2862:13: ( ( ULONG )=> ULONG ( ignoredtail )? )
			// ../rsc/CSharp.g3:2862:15: ( ULONG )=> ULONG ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ULONG1495 =
					(Token) match(this.input, ULONG, FOLLOW_ULONG_in_uLONG20843);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ULONG1495_tree = (Object) this.adaptor.create(ULONG1495);
					this.adaptor.addChild(root_0, ULONG1495_tree);
				}
				// ../rsc/CSharp.g3:2862:32: ( ignoredtail )?
				int alt429 = 2;
				int LA429_0 = this.input.LA(1);

				if (((LA429_0 >= Whitespace && LA429_0 <= Preprocessordirective))) {
					alt429 = 1;
				}
				switch (alt429) {
					case 1 :
					// ../rsc/CSharp.g3:2862:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_uLONG20846);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "uLONG"

	public static class uNCHECKED_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "uNCHECKED"
	// ../rsc/CSharp.g3:2863:1: uNCHECKED : ( UNCHECKED )=> UNCHECKED ( ignoredtail )? ;
	public final CSharpParser.uNCHECKED_return uNCHECKED()
			throws RecognitionException {
		CSharpParser.uNCHECKED_return retval =
			new CSharpParser.uNCHECKED_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token UNCHECKED1497 = null;
		Object UNCHECKED1497_tree = null;

		try {
			// ../rsc/CSharp.g3:2863:13: ( ( UNCHECKED )=> UNCHECKED ( ignoredtail )? )
			// ../rsc/CSharp.g3:2863:15: ( UNCHECKED )=> UNCHECKED ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				UNCHECKED1497 =
					(Token) match(
						this.input,
						UNCHECKED,
						FOLLOW_UNCHECKED_in_uNCHECKED20864);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					UNCHECKED1497_tree = (Object) this.adaptor.create(UNCHECKED1497);
					this.adaptor.addChild(root_0, UNCHECKED1497_tree);
				}
				// ../rsc/CSharp.g3:2863:40: ( ignoredtail )?
				int alt430 = 2;
				int LA430_0 = this.input.LA(1);

				if (((LA430_0 >= Whitespace && LA430_0 <= Preprocessordirective))) {
					alt430 = 1;
				}
				switch (alt430) {
					case 1 :
					// ../rsc/CSharp.g3:2863:41: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_uNCHECKED20867);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "uNCHECKED"

	public static class uNSAFE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "uNSAFE"
	// ../rsc/CSharp.g3:2864:1: uNSAFE : ( UNSAFE )=> UNSAFE ( ignoredtail )? ;
	public final CSharpParser.uNSAFE_return uNSAFE()
			throws RecognitionException {
		CSharpParser.uNSAFE_return retval = new CSharpParser.uNSAFE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token UNSAFE1499 = null;
		Object UNSAFE1499_tree = null;

		try {
			// ../rsc/CSharp.g3:2864:13: ( ( UNSAFE )=> UNSAFE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2864:15: ( UNSAFE )=> UNSAFE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				UNSAFE1499 =
					(Token) match(this.input, UNSAFE, FOLLOW_UNSAFE_in_uNSAFE20888);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					UNSAFE1499_tree = (Object) this.adaptor.create(UNSAFE1499);
					this.adaptor.addChild(root_0, UNSAFE1499_tree);
				}
				// ../rsc/CSharp.g3:2864:34: ( ignoredtail )?
				int alt431 = 2;
				int LA431_0 = this.input.LA(1);

				if (((LA431_0 >= Whitespace && LA431_0 <= Preprocessordirective))) {
					alt431 = 1;
				}
				switch (alt431) {
					case 1 :
					// ../rsc/CSharp.g3:2864:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_uNSAFE20891);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "uNSAFE"

	public static class uSHORT_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "uSHORT"
	// ../rsc/CSharp.g3:2865:1: uSHORT : ( USHORT )=> USHORT ( ignoredtail )? ;
	public final CSharpParser.uSHORT_return uSHORT()
			throws RecognitionException {
		CSharpParser.uSHORT_return retval = new CSharpParser.uSHORT_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token USHORT1501 = null;
		Object USHORT1501_tree = null;

		try {
			// ../rsc/CSharp.g3:2865:13: ( ( USHORT )=> USHORT ( ignoredtail )? )
			// ../rsc/CSharp.g3:2865:15: ( USHORT )=> USHORT ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				USHORT1501 =
					(Token) match(this.input, USHORT, FOLLOW_USHORT_in_uSHORT20912);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					USHORT1501_tree = (Object) this.adaptor.create(USHORT1501);
					this.adaptor.addChild(root_0, USHORT1501_tree);
				}
				// ../rsc/CSharp.g3:2865:34: ( ignoredtail )?
				int alt432 = 2;
				int LA432_0 = this.input.LA(1);

				if (((LA432_0 >= Whitespace && LA432_0 <= Preprocessordirective))) {
					alt432 = 1;
				}
				switch (alt432) {
					case 1 :
					// ../rsc/CSharp.g3:2865:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_uSHORT20915);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "uSHORT"

	public static class uSING_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "uSING"
	// ../rsc/CSharp.g3:2866:1: uSING : ( USING )=> USING ( ignoredtail )? ;
	public final CSharpParser.uSING_return uSING() throws RecognitionException {
		CSharpParser.uSING_return retval = new CSharpParser.uSING_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token USING1503 = null;
		Object USING1503_tree = null;

		try {
			// ../rsc/CSharp.g3:2866:13: ( ( USING )=> USING ( ignoredtail )? )
			// ../rsc/CSharp.g3:2866:15: ( USING )=> USING ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				USING1503 =
					(Token) match(this.input, USING, FOLLOW_USING_in_uSING20937);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					USING1503_tree = (Object) this.adaptor.create(USING1503);
					this.adaptor.addChild(root_0, USING1503_tree);
				}
				// ../rsc/CSharp.g3:2866:32: ( ignoredtail )?
				int alt433 = 2;
				int LA433_0 = this.input.LA(1);

				if (((LA433_0 >= Whitespace && LA433_0 <= Preprocessordirective))) {
					alt433 = 1;
				}
				switch (alt433) {
					case 1 :
					// ../rsc/CSharp.g3:2866:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_uSING20940);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "uSING"

	public static class vIRTUAL_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "vIRTUAL"
	// ../rsc/CSharp.g3:2867:1: vIRTUAL : ( VIRTUAL )=> VIRTUAL ( ignoredtail )? ;
	public final CSharpParser.vIRTUAL_return vIRTUAL()
			throws RecognitionException {
		CSharpParser.vIRTUAL_return retval = new CSharpParser.vIRTUAL_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token VIRTUAL1505 = null;
		Object VIRTUAL1505_tree = null;

		try {
			// ../rsc/CSharp.g3:2867:13: ( ( VIRTUAL )=> VIRTUAL ( ignoredtail )? )
			// ../rsc/CSharp.g3:2867:15: ( VIRTUAL )=> VIRTUAL ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				VIRTUAL1505 =
					(Token) match(
						this.input,
						VIRTUAL,
						FOLLOW_VIRTUAL_in_vIRTUAL20960);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					VIRTUAL1505_tree = (Object) this.adaptor.create(VIRTUAL1505);
					this.adaptor.addChild(root_0, VIRTUAL1505_tree);
				}
				// ../rsc/CSharp.g3:2867:36: ( ignoredtail )?
				int alt434 = 2;
				int LA434_0 = this.input.LA(1);

				if (((LA434_0 >= Whitespace && LA434_0 <= Preprocessordirective))) {
					alt434 = 1;
				}
				switch (alt434) {
					case 1 :
					// ../rsc/CSharp.g3:2867:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_vIRTUAL20963);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "vIRTUAL"

	public static class vOID_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "vOID"
	// ../rsc/CSharp.g3:2868:1: vOID : ( VOID )=> VOID ( ignoredtail )? ;
	public final CSharpParser.vOID_return vOID() throws RecognitionException {
		CSharpParser.vOID_return retval = new CSharpParser.vOID_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token VOID1507 = null;
		Object VOID1507_tree = null;

		try {
			// ../rsc/CSharp.g3:2868:13: ( ( VOID )=> VOID ( ignoredtail )? )
			// ../rsc/CSharp.g3:2868:15: ( VOID )=> VOID ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				VOID1507 = (Token) match(this.input, VOID, FOLLOW_VOID_in_vOID20986);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					VOID1507_tree = (Object) this.adaptor.create(VOID1507);
					this.adaptor.addChild(root_0, VOID1507_tree);
				}
				// ../rsc/CSharp.g3:2868:30: ( ignoredtail )?
				int alt435 = 2;
				int LA435_0 = this.input.LA(1);

				if (((LA435_0 >= Whitespace && LA435_0 <= Preprocessordirective))) {
					alt435 = 1;
				}
				switch (alt435) {
					case 1 :
					// ../rsc/CSharp.g3:2868:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_vOID20989);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "vOID"

	public static class vOLATILE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "vOLATILE"
	// ../rsc/CSharp.g3:2869:1: vOLATILE : ( VOLATILE )=> VOLATILE ( ignoredtail )? ;
	public final CSharpParser.vOLATILE_return vOLATILE()
			throws RecognitionException {
		CSharpParser.vOLATILE_return retval =
			new CSharpParser.vOLATILE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token VOLATILE1509 = null;
		Object VOLATILE1509_tree = null;

		try {
			// ../rsc/CSharp.g3:2869:13: ( ( VOLATILE )=> VOLATILE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2869:15: ( VOLATILE )=> VOLATILE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				VOLATILE1509 =
					(Token) match(
						this.input,
						VOLATILE,
						FOLLOW_VOLATILE_in_vOLATILE21008);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					VOLATILE1509_tree = (Object) this.adaptor.create(VOLATILE1509);
					this.adaptor.addChild(root_0, VOLATILE1509_tree);
				}
				// ../rsc/CSharp.g3:2869:38: ( ignoredtail )?
				int alt436 = 2;
				int LA436_0 = this.input.LA(1);

				if (((LA436_0 >= Whitespace && LA436_0 <= Preprocessordirective))) {
					alt436 = 1;
				}
				switch (alt436) {
					case 1 :
					// ../rsc/CSharp.g3:2869:39: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_vOLATILE21011);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "vOLATILE"

	public static class wHILE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "wHILE"
	// ../rsc/CSharp.g3:2870:1: wHILE : ( WHILE )=> WHILE ( ignoredtail )? ;
	public final CSharpParser.wHILE_return wHILE() throws RecognitionException {
		CSharpParser.wHILE_return retval = new CSharpParser.wHILE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token WHILE1511 = null;
		Object WHILE1511_tree = null;

		try {
			// ../rsc/CSharp.g3:2870:13: ( ( WHILE )=> WHILE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2870:15: ( WHILE )=> WHILE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				WHILE1511 =
					(Token) match(this.input, WHILE, FOLLOW_WHILE_in_wHILE21033);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					WHILE1511_tree = (Object) this.adaptor.create(WHILE1511);
					this.adaptor.addChild(root_0, WHILE1511_tree);
				}
				// ../rsc/CSharp.g3:2870:32: ( ignoredtail )?
				int alt437 = 2;
				int LA437_0 = this.input.LA(1);

				if (((LA437_0 >= Whitespace && LA437_0 <= Preprocessordirective))) {
					alt437 = 1;
				}
				switch (alt437) {
					case 1 :
					// ../rsc/CSharp.g3:2870:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_wHILE21036);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "wHILE"

	public static class aDD_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "aDD"
	// ../rsc/CSharp.g3:2872:1: aDD : ( ADD )=> ADD ( ignoredtail )? ;
	public final CSharpParser.aDD_return aDD() throws RecognitionException {
		CSharpParser.aDD_return retval = new CSharpParser.aDD_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ADD1513 = null;
		Object ADD1513_tree = null;

		try {
			// ../rsc/CSharp.g3:2872:13: ( ( ADD )=> ADD ( ignoredtail )? )
			// ../rsc/CSharp.g3:2872:15: ( ADD )=> ADD ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ADD1513 = (Token) match(this.input, ADD, FOLLOW_ADD_in_aDD21061);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ADD1513_tree = (Object) this.adaptor.create(ADD1513);
					this.adaptor.addChild(root_0, ADD1513_tree);
				}
				// ../rsc/CSharp.g3:2872:28: ( ignoredtail )?
				int alt438 = 2;
				int LA438_0 = this.input.LA(1);

				if (((LA438_0 >= Whitespace && LA438_0 <= Preprocessordirective))) {
					alt438 = 1;
				}
				switch (alt438) {
					case 1 :
					// ../rsc/CSharp.g3:2872:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_aDD21064);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "aDD"

	public static class aLIAS_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "aLIAS"
	// ../rsc/CSharp.g3:2873:1: aLIAS : ( ALIAS )=> ALIAS ( ignoredtail )? ;
	public final CSharpParser.aLIAS_return aLIAS() throws RecognitionException {
		CSharpParser.aLIAS_return retval = new CSharpParser.aLIAS_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token ALIAS1515 = null;
		Object ALIAS1515_tree = null;

		try {
			// ../rsc/CSharp.g3:2873:13: ( ( ALIAS )=> ALIAS ( ignoredtail )? )
			// ../rsc/CSharp.g3:2873:15: ( ALIAS )=> ALIAS ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				ALIAS1515 =
					(Token) match(this.input, ALIAS, FOLLOW_ALIAS_in_aLIAS21086);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					ALIAS1515_tree = (Object) this.adaptor.create(ALIAS1515);
					this.adaptor.addChild(root_0, ALIAS1515_tree);
				}
				// ../rsc/CSharp.g3:2873:32: ( ignoredtail )?
				int alt439 = 2;
				int LA439_0 = this.input.LA(1);

				if (((LA439_0 >= Whitespace && LA439_0 <= Preprocessordirective))) {
					alt439 = 1;
				}
				switch (alt439) {
					case 1 :
					// ../rsc/CSharp.g3:2873:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_aLIAS21089);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "aLIAS"

	public static class gET_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "gET"
	// ../rsc/CSharp.g3:2874:1: gET : ( GET )=> GET ( ignoredtail )? ;
	public final CSharpParser.gET_return gET() throws RecognitionException {
		CSharpParser.gET_return retval = new CSharpParser.gET_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token GET1517 = null;
		Object GET1517_tree = null;

		try {
			// ../rsc/CSharp.g3:2874:13: ( ( GET )=> GET ( ignoredtail )? )
			// ../rsc/CSharp.g3:2874:15: ( GET )=> GET ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				GET1517 = (Token) match(this.input, GET, FOLLOW_GET_in_gET21113);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					GET1517_tree = (Object) this.adaptor.create(GET1517);
					this.adaptor.addChild(root_0, GET1517_tree);
				}
				// ../rsc/CSharp.g3:2874:28: ( ignoredtail )?
				int alt440 = 2;
				int LA440_0 = this.input.LA(1);

				if (((LA440_0 >= Whitespace && LA440_0 <= Preprocessordirective))) {
					alt440 = 1;
				}
				switch (alt440) {
					case 1 :
					// ../rsc/CSharp.g3:2874:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_gET21116);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "gET"

	public static class pARTIAL_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "pARTIAL"
	// ../rsc/CSharp.g3:2875:1: pARTIAL : ( PARTIAL )=> PARTIAL ( ignoredtail )? ;
	public final CSharpParser.pARTIAL_return pARTIAL()
			throws RecognitionException {
		CSharpParser.pARTIAL_return retval = new CSharpParser.pARTIAL_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token PARTIAL1519 = null;
		Object PARTIAL1519_tree = null;

		try {
			// ../rsc/CSharp.g3:2875:13: ( ( PARTIAL )=> PARTIAL ( ignoredtail )? )
			// ../rsc/CSharp.g3:2875:15: ( PARTIAL )=> PARTIAL ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				PARTIAL1519 =
					(Token) match(
						this.input,
						PARTIAL,
						FOLLOW_PARTIAL_in_pARTIAL21136);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					PARTIAL1519_tree = (Object) this.adaptor.create(PARTIAL1519);
					this.adaptor.addChild(root_0, PARTIAL1519_tree);
				}
				// ../rsc/CSharp.g3:2875:36: ( ignoredtail )?
				int alt441 = 2;
				int LA441_0 = this.input.LA(1);

				if (((LA441_0 >= Whitespace && LA441_0 <= Preprocessordirective))) {
					alt441 = 1;
				}
				switch (alt441) {
					case 1 :
					// ../rsc/CSharp.g3:2875:37: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_pARTIAL21139);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "pARTIAL"

	public static class rEMOVE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "rEMOVE"
	// ../rsc/CSharp.g3:2876:1: rEMOVE : ( REMOVE )=> REMOVE ( ignoredtail )? ;
	public final CSharpParser.rEMOVE_return rEMOVE()
			throws RecognitionException {
		CSharpParser.rEMOVE_return retval = new CSharpParser.rEMOVE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token REMOVE1521 = null;
		Object REMOVE1521_tree = null;

		try {
			// ../rsc/CSharp.g3:2876:13: ( ( REMOVE )=> REMOVE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2876:15: ( REMOVE )=> REMOVE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				REMOVE1521 =
					(Token) match(this.input, REMOVE, FOLLOW_REMOVE_in_rEMOVE21160);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					REMOVE1521_tree = (Object) this.adaptor.create(REMOVE1521);
					this.adaptor.addChild(root_0, REMOVE1521_tree);
				}
				// ../rsc/CSharp.g3:2876:34: ( ignoredtail )?
				int alt442 = 2;
				int LA442_0 = this.input.LA(1);

				if (((LA442_0 >= Whitespace && LA442_0 <= Preprocessordirective))) {
					alt442 = 1;
				}
				switch (alt442) {
					case 1 :
					// ../rsc/CSharp.g3:2876:35: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_rEMOVE21163);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "rEMOVE"

	public static class sET_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "sET"
	// ../rsc/CSharp.g3:2877:1: sET : ( SET )=> SET ( ignoredtail )? ;
	public final CSharpParser.sET_return sET() throws RecognitionException {
		CSharpParser.sET_return retval = new CSharpParser.sET_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token SET1523 = null;
		Object SET1523_tree = null;

		try {
			// ../rsc/CSharp.g3:2877:13: ( ( SET )=> SET ( ignoredtail )? )
			// ../rsc/CSharp.g3:2877:15: ( SET )=> SET ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				SET1523 = (Token) match(this.input, SET, FOLLOW_SET_in_sET21187);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					SET1523_tree = (Object) this.adaptor.create(SET1523);
					this.adaptor.addChild(root_0, SET1523_tree);
				}
				// ../rsc/CSharp.g3:2877:28: ( ignoredtail )?
				int alt443 = 2;
				int LA443_0 = this.input.LA(1);

				if (((LA443_0 >= Whitespace && LA443_0 <= Preprocessordirective))) {
					alt443 = 1;
				}
				switch (alt443) {
					case 1 :
					// ../rsc/CSharp.g3:2877:29: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_sET21190);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "sET"

	public static class wHERE_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "wHERE"
	// ../rsc/CSharp.g3:2878:1: wHERE : ( WHERE )=> WHERE ( ignoredtail )? ;
	public final CSharpParser.wHERE_return wHERE() throws RecognitionException {
		CSharpParser.wHERE_return retval = new CSharpParser.wHERE_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token WHERE1525 = null;
		Object WHERE1525_tree = null;

		try {
			// ../rsc/CSharp.g3:2878:13: ( ( WHERE )=> WHERE ( ignoredtail )? )
			// ../rsc/CSharp.g3:2878:15: ( WHERE )=> WHERE ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				WHERE1525 =
					(Token) match(this.input, WHERE, FOLLOW_WHERE_in_wHERE21212);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					WHERE1525_tree = (Object) this.adaptor.create(WHERE1525);
					this.adaptor.addChild(root_0, WHERE1525_tree);
				}
				// ../rsc/CSharp.g3:2878:32: ( ignoredtail )?
				int alt444 = 2;
				int LA444_0 = this.input.LA(1);

				if (((LA444_0 >= Whitespace && LA444_0 <= Preprocessordirective))) {
					alt444 = 1;
				}
				switch (alt444) {
					case 1 :
					// ../rsc/CSharp.g3:2878:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_wHERE21215);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "wHERE"

	public static class yIELD_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "yIELD"
	// ../rsc/CSharp.g3:2879:1: yIELD : ( YIELD )=> YIELD ( ignoredtail )? ;
	public final CSharpParser.yIELD_return yIELD() throws RecognitionException {
		CSharpParser.yIELD_return retval = new CSharpParser.yIELD_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token YIELD1527 = null;
		Object YIELD1527_tree = null;

		try {
			// ../rsc/CSharp.g3:2879:13: ( ( YIELD )=> YIELD ( ignoredtail )? )
			// ../rsc/CSharp.g3:2879:15: ( YIELD )=> YIELD ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				YIELD1527 =
					(Token) match(this.input, YIELD, FOLLOW_YIELD_in_yIELD21237);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					YIELD1527_tree = (Object) this.adaptor.create(YIELD1527);
					this.adaptor.addChild(root_0, YIELD1527_tree);
				}
				// ../rsc/CSharp.g3:2879:32: ( ignoredtail )?
				int alt445 = 2;
				int LA445_0 = this.input.LA(1);

				if (((LA445_0 >= Whitespace && LA445_0 <= Preprocessordirective))) {
					alt445 = 1;
				}
				switch (alt445) {
					case 1 :
					// ../rsc/CSharp.g3:2879:33: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_yIELD21240);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "yIELD"

	public static class ident_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "ident"
	// ../rsc/CSharp.g3:2882:1: ident : ( Ident )=> Ident ( ignoredtail )? ;
	public final CSharpParser.ident_return ident() throws RecognitionException {
		CSharpParser.ident_return retval = new CSharpParser.ident_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token Ident1529 = null;
		Object Ident1529_tree = null;

		try {
			// ../rsc/CSharp.g3:2882:11: ( ( Ident )=> Ident ( ignoredtail )? )
			// ../rsc/CSharp.g3:2882:13: ( Ident )=> Ident ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				Ident1529 =
					(Token) match(this.input, Ident, FOLLOW_Ident_in_ident21262);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					Ident1529_tree = (Object) this.adaptor.create(Ident1529);
					this.adaptor.addChild(root_0, Ident1529_tree);
				}
				// ../rsc/CSharp.g3:2882:30: ( ignoredtail )?
				int alt446 = 2;
				int LA446_0 = this.input.LA(1);

				if (((LA446_0 >= Whitespace && LA446_0 <= Preprocessordirective))) {
					alt446 = 1;
				}
				switch (alt446) {
					case 1 :
					// ../rsc/CSharp.g3:2882:31: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_ident21265);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "ident"

	public static class integerliteral_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "integerliteral"
	// ../rsc/CSharp.g3:2883:1: integerliteral : ( Integerliteral )=> Integerliteral ( ignoredtail )? ;
	public final CSharpParser.integerliteral_return integerliteral()
			throws RecognitionException {
		CSharpParser.integerliteral_return retval =
			new CSharpParser.integerliteral_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token Integerliteral1531 = null;
		Object Integerliteral1531_tree = null;

		try {
			// ../rsc/CSharp.g3:2883:17: ( ( Integerliteral )=> Integerliteral ( ignoredtail )? )
			// ../rsc/CSharp.g3:2883:19: ( Integerliteral )=> Integerliteral ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				Integerliteral1531 =
					(Token) match(
						this.input,
						Integerliteral,
						FOLLOW_Integerliteral_in_integerliteral21283);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					Integerliteral1531_tree =
						(Object) this.adaptor.create(Integerliteral1531);
					this.adaptor.addChild(root_0, Integerliteral1531_tree);
				}
				// ../rsc/CSharp.g3:2883:54: ( ignoredtail )?
				int alt447 = 2;
				int LA447_0 = this.input.LA(1);

				if (((LA447_0 >= Whitespace && LA447_0 <= Preprocessordirective))) {
					alt447 = 1;
				}
				switch (alt447) {
					case 1 :
					// ../rsc/CSharp.g3:2883:55: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_integerliteral21286);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "integerliteral"

	public static class realliteral_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "realliteral"
	// ../rsc/CSharp.g3:2884:1: realliteral : ( Realliteral )=> Realliteral ( ignoredtail )? ;
	public final CSharpParser.realliteral_return realliteral()
			throws RecognitionException {
		CSharpParser.realliteral_return retval =
			new CSharpParser.realliteral_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token Realliteral1533 = null;
		Object Realliteral1533_tree = null;

		try {
			// ../rsc/CSharp.g3:2884:15: ( ( Realliteral )=> Realliteral ( ignoredtail )? )
			// ../rsc/CSharp.g3:2884:17: ( Realliteral )=> Realliteral ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				Realliteral1533 =
					(Token) match(
						this.input,
						Realliteral,
						FOLLOW_Realliteral_in_realliteral21304);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					Realliteral1533_tree =
						(Object) this.adaptor.create(Realliteral1533);
					this.adaptor.addChild(root_0, Realliteral1533_tree);
				}
				// ../rsc/CSharp.g3:2884:46: ( ignoredtail )?
				int alt448 = 2;
				int LA448_0 = this.input.LA(1);

				if (((LA448_0 >= Whitespace && LA448_0 <= Preprocessordirective))) {
					alt448 = 1;
				}
				switch (alt448) {
					case 1 :
					// ../rsc/CSharp.g3:2884:47: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_realliteral21307);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "realliteral"

	public static class characterliteral_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "characterliteral"
	// ../rsc/CSharp.g3:2885:1: characterliteral : ( Characterliteral )=> Characterliteral ( ignoredtail )? ;
	public final CSharpParser.characterliteral_return characterliteral()
			throws RecognitionException {
		CSharpParser.characterliteral_return retval =
			new CSharpParser.characterliteral_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token Characterliteral1535 = null;
		Object Characterliteral1535_tree = null;

		try {
			// ../rsc/CSharp.g3:2885:18: ( ( Characterliteral )=> Characterliteral ( ignoredtail )? )
			// ../rsc/CSharp.g3:2885:20: ( Characterliteral )=> Characterliteral ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				Characterliteral1535 =
					(Token) match(
						this.input,
						Characterliteral,
						FOLLOW_Characterliteral_in_characterliteral21323);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					Characterliteral1535_tree =
						(Object) this.adaptor.create(Characterliteral1535);
					this.adaptor.addChild(root_0, Characterliteral1535_tree);
				}
				// ../rsc/CSharp.g3:2885:59: ( ignoredtail )?
				int alt449 = 2;
				int LA449_0 = this.input.LA(1);

				if (((LA449_0 >= Whitespace && LA449_0 <= Preprocessordirective))) {
					alt449 = 1;
				}
				switch (alt449) {
					case 1 :
					// ../rsc/CSharp.g3:2885:60: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_characterliteral21326);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "characterliteral"

	public static class stringliteral_return extends ParserRuleReturnScope {
		Object tree;
		public Object getTree() {
			return this.tree;
		}
	};

	// $ANTLR start "stringliteral"
	// ../rsc/CSharp.g3:2886:1: stringliteral : ( Stringliteral )=> Stringliteral ( ignoredtail )? ;
	public final CSharpParser.stringliteral_return stringliteral()
			throws RecognitionException {
		CSharpParser.stringliteral_return retval =
			new CSharpParser.stringliteral_return();
		retval.start = this.input.LT(1);

		Object root_0 = null;

		Token Stringliteral1537 = null;
		Object Stringliteral1537_tree = null;

		try {
			// ../rsc/CSharp.g3:2886:16: ( ( Stringliteral )=> Stringliteral ( ignoredtail )? )
			// ../rsc/CSharp.g3:2886:18: ( Stringliteral )=> Stringliteral ( ignoredtail )?
			{
				root_0 = (Object) this.adaptor.nil();

				Stringliteral1537 =
					(Token) match(
						this.input,
						Stringliteral,
						FOLLOW_Stringliteral_in_stringliteral21343);
				if (this.state.failed)
					return retval;
				if (this.state.backtracking == 0) {
					Stringliteral1537_tree =
						(Object) this.adaptor.create(Stringliteral1537);
					this.adaptor.addChild(root_0, Stringliteral1537_tree);
				}
				// ../rsc/CSharp.g3:2886:51: ( ignoredtail )?
				int alt450 = 2;
				int LA450_0 = this.input.LA(1);

				if (((LA450_0 >= Whitespace && LA450_0 <= Preprocessordirective))) {
					alt450 = 1;
				}
				switch (alt450) {
					case 1 :
					// ../rsc/CSharp.g3:2886:52: ignoredtail
						{
							pushFollow(FOLLOW_ignoredtail_in_stringliteral21346);
							ignoredtail();

							this.state._fsp--;
							if (this.state.failed)
								return retval;

						}
						break;

				}

			}

			retval.stop = this.input.LT(-1);

			if (this.state.backtracking == 0) {

				retval.tree = (Object) this.adaptor.rulePostProcessing(root_0);
				this.adaptor.setTokenBoundaries(
					retval.tree,
					retval.start,
					retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(this.input, re);
			retval.tree =
				(Object) this.adaptor.errorNode(
					this.input,
					retval.start,
					this.input.LT(-1),
					re);

		}
		finally {
		}
		return retval;
	}
	// $ANTLR end "stringliteral"

	// $ANTLR start synpred88_CSharp
	public final void synpred88_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:366:62: ( globalattributes )
		// ../rsc/CSharp.g3:366:62: globalattributes
		{
			pushFollow(FOLLOW_globalattributes_in_synpred88_CSharp1429);
			globalattributes();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred88_CSharp

	// $ANTLR start synpred90_CSharp
	public final void synpred90_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:391:5: ( simplenamespaceortypename dOT )
		// ../rsc/CSharp.g3:391:5: simplenamespaceortypename dOT
		{
			pushFollow(FOLLOW_simplenamespaceortypename_in_synpred90_CSharp1560);
			simplenamespaceortypename();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_dOT_in_synpred90_CSharp1562);
			dOT();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred90_CSharp

	// $ANTLR start synpred91_CSharp
	public final void synpred91_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:392:14: ( typeargumentlist )
		// ../rsc/CSharp.g3:392:14: typeargumentlist
		{
			pushFollow(FOLLOW_typeargumentlist_in_synpred91_CSharp1572);
			typeargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred91_CSharp

	// $ANTLR start synpred92_CSharp
	public final void synpred92_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:391:4: ( ( simplenamespaceortypename dOT )+ identifier ( typeargumentlist )? )
		// ../rsc/CSharp.g3:391:4: ( simplenamespaceortypename dOT )+ identifier ( typeargumentlist )?
		{
			// ../rsc/CSharp.g3:391:4: ( simplenamespaceortypename dOT )+
			int cnt451 = 0;
			loop451: do {
				int alt451 = 2;
				alt451 = this.dfa451.predict(this.input);
				switch (alt451) {
					case 1 :
					// ../rsc/CSharp.g3:391:5: simplenamespaceortypename dOT
						{
							pushFollow(FOLLOW_simplenamespaceortypename_in_synpred92_CSharp1560);
							simplenamespaceortypename();

							this.state._fsp--;
							if (this.state.failed)
								return;
							pushFollow(FOLLOW_dOT_in_synpred92_CSharp1562);
							dOT();

							this.state._fsp--;
							if (this.state.failed)
								return;

						}
						break;

					default :
						if (cnt451 >= 1)
							break loop451;
						if (this.state.backtracking > 0) {
							this.state.failed = true;
							return;
						}
						EarlyExitException eee =
							new EarlyExitException(451, this.input);
						throw eee;
				}
				cnt451++;
			}
			while (true);

			pushFollow(FOLLOW_identifier_in_synpred92_CSharp1570);
			identifier();

			this.state._fsp--;
			if (this.state.failed)
				return;
			// ../rsc/CSharp.g3:392:14: ( typeargumentlist )?
			int alt452 = 2;
			int LA452_0 = this.input.LA(1);

			if ((LA452_0 == LT)) {
				alt452 = 1;
			}
			switch (alt452) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: typeargumentlist
					{
						pushFollow(FOLLOW_typeargumentlist_in_synpred92_CSharp1572);
						typeargumentlist();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

		}
	}
	// $ANTLR end synpred92_CSharp

	// $ANTLR start synpred93_CSharp
	public final void synpred93_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:398:15: ( typeargumentlist )
		// ../rsc/CSharp.g3:398:15: typeargumentlist
		{
			pushFollow(FOLLOW_typeargumentlist_in_synpred93_CSharp1600);
			typeargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred93_CSharp

	// $ANTLR start synpred95_CSharp
	public final void synpred95_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:407:9: ( referencetype )
		// ../rsc/CSharp.g3:407:9: referencetype
		{
			pushFollow(FOLLOW_referencetype_in_synpred95_CSharp1636);
			referencetype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred95_CSharp

	// $ANTLR start synpred96_CSharp
	public final void synpred96_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:410:7: ( valuetype )
		// ../rsc/CSharp.g3:410:7: valuetype
		{
			pushFollow(FOLLOW_valuetype_in_synpred96_CSharp1670);
			valuetype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred96_CSharp

	// $ANTLR start synpred97_CSharp
	public final void synpred97_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:419:9: ( structtype )
		// ../rsc/CSharp.g3:419:9: structtype
		{
			pushFollow(FOLLOW_structtype_in_synpred97_CSharp1741);
			structtype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred97_CSharp

	// $ANTLR start synpred98_CSharp
	public final void synpred98_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:426:9: ( nullabletype )
		// ../rsc/CSharp.g3:426:9: nullabletype
		{
			pushFollow(FOLLOW_nullabletype_in_synpred98_CSharp1788);
			nullabletype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred98_CSharp

	// $ANTLR start synpred99_CSharp
	public final void synpred99_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:428:7: ( typename )
		// ../rsc/CSharp.g3:428:7: typename
		{
			pushFollow(FOLLOW_typename_in_synpred99_CSharp1809);
			typename();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred99_CSharp

	// $ANTLR start synpred112_CSharp
	public final void synpred112_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:478:9: ( enumtype )
		// ../rsc/CSharp.g3:478:9: enumtype
		{
			pushFollow(FOLLOW_enumtype_in_synpred112_CSharp2180);
			enumtype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred112_CSharp

	// $ANTLR start synpred113_CSharp
	public final void synpred113_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:480:7: ( typename )
		// ../rsc/CSharp.g3:480:7: typename
		{
			pushFollow(FOLLOW_typename_in_synpred113_CSharp2195);
			typename();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred113_CSharp

	// $ANTLR start synpred115_CSharp
	public final void synpred115_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:489:7: ( classtype )
		// ../rsc/CSharp.g3:489:7: classtype
		{
			pushFollow(FOLLOW_classtype_in_synpred115_CSharp2266);
			classtype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred115_CSharp

	// $ANTLR start synpred116_CSharp
	public final void synpred116_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:491:9: ( interfacetype )
		// ../rsc/CSharp.g3:491:9: interfacetype
		{
			pushFollow(FOLLOW_interfacetype_in_synpred116_CSharp2283);
			interfacetype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred116_CSharp

	// $ANTLR start synpred122_CSharp
	public final void synpred122_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:562:4: ( primarynoarraycreationexpression )
		// ../rsc/CSharp.g3:562:4: primarynoarraycreationexpression
		{
			pushFollow(FOLLOW_primarynoarraycreationexpression_in_synpred122_CSharp2613);
			primarynoarraycreationexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred122_CSharp

	// $ANTLR start synpred123_CSharp
	public final void synpred123_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:568:4: ( arraycreationexpression_withoutinitializer )
		// ../rsc/CSharp.g3:568:4: arraycreationexpression_withoutinitializer
		{
			pushFollow(FOLLOW_arraycreationexpression_withoutinitializer_in_synpred123_CSharp2630);
			arraycreationexpression_withoutinitializer();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred123_CSharp

	// $ANTLR start synpred124_CSharp
	public final void synpred124_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:573:4: ( memberaccess_rec_rest )
		// ../rsc/CSharp.g3:573:4: memberaccess_rec_rest
		{
			pushFollow(FOLLOW_memberaccess_rec_rest_in_synpred124_CSharp2646);
			memberaccess_rec_rest();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred124_CSharp

	// $ANTLR start synpred125_CSharp
	public final void synpred125_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:574:4: ( invocationexpression )
		// ../rsc/CSharp.g3:574:4: invocationexpression
		{
			pushFollow(FOLLOW_invocationexpression_in_synpred125_CSharp2651);
			invocationexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred125_CSharp

	// $ANTLR start synpred126_CSharp
	public final void synpred126_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:575:4: ( elementaccess )
		// ../rsc/CSharp.g3:575:4: elementaccess
		{
			pushFollow(FOLLOW_elementaccess_in_synpred126_CSharp2656);
			elementaccess();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred126_CSharp

	// $ANTLR start synpred127_CSharp
	public final void synpred127_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:576:4: ( postincrementexpression )
		// ../rsc/CSharp.g3:576:4: postincrementexpression
		{
			pushFollow(FOLLOW_postincrementexpression_in_synpred127_CSharp2661);
			postincrementexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred127_CSharp

	// $ANTLR start synpred128_CSharp
	public final void synpred128_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:577:4: ( postdecrementexpression )
		// ../rsc/CSharp.g3:577:4: postdecrementexpression
		{
			pushFollow(FOLLOW_postdecrementexpression_in_synpred128_CSharp2666);
			postdecrementexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred128_CSharp

	// $ANTLR start synpred129_CSharp
	public final void synpred129_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:587:5: ( arraycreationexpression_withinitializer )
		// ../rsc/CSharp.g3:587:5: arraycreationexpression_withinitializer
		{
			pushFollow(FOLLOW_arraycreationexpression_withinitializer_in_synpred129_CSharp2686);
			arraycreationexpression_withinitializer();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred129_CSharp

	// $ANTLR start synpred131_CSharp
	public final void synpred131_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:589:4: ( simplename )
		// ../rsc/CSharp.g3:589:4: simplename
		{
			pushFollow(FOLLOW_simplename_in_synpred131_CSharp2696);
			simplename();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred131_CSharp

	// $ANTLR start synpred133_CSharp
	public final void synpred133_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:591:4: ( memberaccess_nonrec )
		// ../rsc/CSharp.g3:591:4: memberaccess_nonrec
		{
			pushFollow(FOLLOW_memberaccess_nonrec_in_synpred133_CSharp2706);
			memberaccess_nonrec();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred133_CSharp

	// $ANTLR start synpred136_CSharp
	public final void synpred136_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:594:4: ( objectcreationexpression )
		// ../rsc/CSharp.g3:594:4: objectcreationexpression
		{
			pushFollow(FOLLOW_objectcreationexpression_in_synpred136_CSharp2721);
			objectcreationexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred136_CSharp

	// $ANTLR start synpred141_CSharp
	public final void synpred141_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:607:34: ( typeargumentlist )
		// ../rsc/CSharp.g3:607:34: typeargumentlist
		{
			pushFollow(FOLLOW_typeargumentlist_in_synpred141_CSharp2766);
			typeargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred141_CSharp

	// $ANTLR start synpred143_CSharp
	public final void synpred143_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:609:40: ( typeargumentlist )
		// ../rsc/CSharp.g3:609:40: typeargumentlist
		{
			pushFollow(FOLLOW_typeargumentlist_in_synpred143_CSharp2794);
			typeargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred143_CSharp

	// $ANTLR start synpred149_CSharp
	public final void synpred149_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:629:19: ( typeargumentlist )
		// ../rsc/CSharp.g3:629:19: typeargumentlist
		{
			pushFollow(FOLLOW_typeargumentlist_in_synpred149_CSharp2953);
			typeargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred149_CSharp

	// $ANTLR start synpred171_CSharp
	public final void synpred171_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:723:20: ( typeargumentlist )
		// ../rsc/CSharp.g3:723:20: typeargumentlist
		{
			pushFollow(FOLLOW_typeargumentlist_in_synpred171_CSharp3538);
			typeargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred171_CSharp

	// $ANTLR start synpred187_CSharp
	public final void synpred187_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:752:29: ( typeargumentlist )
		// ../rsc/CSharp.g3:752:29: typeargumentlist
		{
			pushFollow(FOLLOW_typeargumentlist_in_synpred187_CSharp3786);
			typeargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred187_CSharp

	// $ANTLR start synpred190_CSharp
	public final void synpred190_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:767:4: ( arraycreationexpression_withinitializer )
		// ../rsc/CSharp.g3:767:4: arraycreationexpression_withinitializer
		{
			pushFollow(FOLLOW_arraycreationexpression_withinitializer_in_synpred190_CSharp3906);
			arraycreationexpression_withinitializer();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred190_CSharp

	// $ANTLR start synpred192_CSharp
	public final void synpred192_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:775:9: ( nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer )
		// ../rsc/CSharp.g3:775:9: nEW nonarraytype lBRACKET expressionlist rBRACKET ( rankspecifiers )? arrayinitializer
		{
			pushFollow(FOLLOW_nEW_in_synpred192_CSharp3932);
			nEW();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_nonarraytype_in_synpred192_CSharp3934);
			nonarraytype();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_lBRACKET_in_synpred192_CSharp3936);
			lBRACKET();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_expressionlist_in_synpred192_CSharp3938);
			expressionlist();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_rBRACKET_in_synpred192_CSharp3940);
			rBRACKET();

			this.state._fsp--;
			if (this.state.failed)
				return;
			// ../rsc/CSharp.g3:775:59: ( rankspecifiers )?
			int alt461 = 2;
			int LA461_0 = this.input.LA(1);

			if ((LA461_0 == LBRACKET)) {
				alt461 = 1;
			}
			switch (alt461) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: rankspecifiers
					{
						pushFollow(FOLLOW_rankspecifiers_in_synpred192_CSharp3942);
						rankspecifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_arrayinitializer_in_synpred192_CSharp3945);
			arrayinitializer();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred192_CSharp

	// $ANTLR start synpred194_CSharp
	public final void synpred194_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:799:9: ( tYPEOF lPAREN type rPAREN )
		// ../rsc/CSharp.g3:799:9: tYPEOF lPAREN type rPAREN
		{
			pushFollow(FOLLOW_tYPEOF_in_synpred194_CSharp4098);
			tYPEOF();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_lPAREN_in_synpred194_CSharp4100);
			lPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_type_in_synpred194_CSharp4102);
			type();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_rPAREN_in_synpred194_CSharp4104);
			rPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred194_CSharp

	// $ANTLR start synpred195_CSharp
	public final void synpred195_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:801:9: ( tYPEOF lPAREN unboundtypename rPAREN )
		// ../rsc/CSharp.g3:801:9: tYPEOF lPAREN unboundtypename rPAREN
		{
			pushFollow(FOLLOW_tYPEOF_in_synpred195_CSharp4132);
			tYPEOF();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_lPAREN_in_synpred195_CSharp4134);
			lPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_unboundtypename_in_synpred195_CSharp4136);
			unboundtypename();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_rPAREN_in_synpred195_CSharp4138);
			rPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred195_CSharp

	// $ANTLR start synpred209_CSharp
	public final void synpred209_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:856:9: ( castexpression )
		// ../rsc/CSharp.g3:856:9: castexpression
		{
			pushFollow(FOLLOW_castexpression_in_synpred209_CSharp4663);
			castexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred209_CSharp

	// $ANTLR start synpred210_CSharp
	public final void synpred210_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:857:7: ( primaryexpression )
		// ../rsc/CSharp.g3:857:7: primaryexpression
		{
			pushFollow(FOLLOW_primaryexpression_in_synpred210_CSharp4673);
			primaryexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred210_CSharp

	// $ANTLR start synpred248_CSharp
	public final void synpred248_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:987:9: ( assignment )
		// ../rsc/CSharp.g3:987:9: assignment
		{
			pushFollow(FOLLOW_assignment_in_synpred248_CSharp5990);
			assignment();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred248_CSharp

	// $ANTLR start synpred249_CSharp
	public final void synpred249_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1006:9: ( labeledstatement )
		// ../rsc/CSharp.g3:1006:9: labeledstatement
		{
			pushFollow(FOLLOW_labeledstatement_in_synpred249_CSharp6102);
			labeledstatement();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred249_CSharp

	// $ANTLR start synpred250_CSharp
	public final void synpred250_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1008:9: ( declarationstatement )
		// ../rsc/CSharp.g3:1008:9: declarationstatement
		{
			pushFollow(FOLLOW_declarationstatement_in_synpred250_CSharp6124);
			declarationstatement();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred250_CSharp

	// $ANTLR start synpred268_CSharp
	public final void synpred268_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1087:8: ( invocationexpression )
		// ../rsc/CSharp.g3:1087:8: invocationexpression
		{
			pushFollow(FOLLOW_invocationexpression_in_synpred268_CSharp6705);
			invocationexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred268_CSharp

	// $ANTLR start synpred269_CSharp
	public final void synpred269_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1089:6: ( objectcreationexpression )
		// ../rsc/CSharp.g3:1089:6: objectcreationexpression
		{
			pushFollow(FOLLOW_objectcreationexpression_in_synpred269_CSharp6727);
			objectcreationexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred269_CSharp

	// $ANTLR start synpred270_CSharp
	public final void synpred270_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1090:9: ( assignment )
		// ../rsc/CSharp.g3:1090:9: assignment
		{
			pushFollow(FOLLOW_assignment_in_synpred270_CSharp6737);
			assignment();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred270_CSharp

	// $ANTLR start synpred271_CSharp
	public final void synpred271_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1091:9: ( postincrementexpression )
		// ../rsc/CSharp.g3:1091:9: postincrementexpression
		{
			pushFollow(FOLLOW_postincrementexpression_in_synpred271_CSharp6747);
			postincrementexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred271_CSharp

	// $ANTLR start synpred272_CSharp
	public final void synpred272_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1092:9: ( postdecrementexpression )
		// ../rsc/CSharp.g3:1092:9: postdecrementexpression
		{
			pushFollow(FOLLOW_postdecrementexpression_in_synpred272_CSharp6757);
			postdecrementexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred272_CSharp

	// $ANTLR start synpred273_CSharp
	public final void synpred273_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1093:9: ( preincrementexpression )
		// ../rsc/CSharp.g3:1093:9: preincrementexpression
		{
			pushFollow(FOLLOW_preincrementexpression_in_synpred273_CSharp6767);
			preincrementexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred273_CSharp

	// $ANTLR start synpred275_CSharp
	public final void synpred275_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1103:9: ( iF lPAREN booleanexpression rPAREN embeddedstatement eLSE embeddedstatement )
		// ../rsc/CSharp.g3:1103:9: iF lPAREN booleanexpression rPAREN embeddedstatement eLSE embeddedstatement
		{
			pushFollow(FOLLOW_iF_in_synpred275_CSharp6825);
			iF();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_lPAREN_in_synpred275_CSharp6827);
			lPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_booleanexpression_in_synpred275_CSharp6829);
			booleanexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_rPAREN_in_synpred275_CSharp6831);
			rPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_embeddedstatement_in_synpred275_CSharp6833);
			embeddedstatement();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_eLSE_in_synpred275_CSharp6835);
			eLSE();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_embeddedstatement_in_synpred275_CSharp6837);
			embeddedstatement();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred275_CSharp

	// $ANTLR start synpred286_CSharp
	public final void synpred286_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1164:9: ( localvariabledeclaration )
		// ../rsc/CSharp.g3:1164:9: localvariabledeclaration
		{
			pushFollow(FOLLOW_localvariabledeclaration_in_synpred286_CSharp7382);
			localvariabledeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred286_CSharp

	// $ANTLR start synpred297_CSharp
	public final void synpred297_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1227:9: ( tRY block ( catchclauses )? finallyclause )
		// ../rsc/CSharp.g3:1227:9: tRY block ( catchclauses )? finallyclause
		{
			pushFollow(FOLLOW_tRY_in_synpred297_CSharp7896);
			tRY();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_block_in_synpred297_CSharp7898);
			block();

			this.state._fsp--;
			if (this.state.failed)
				return;
			// ../rsc/CSharp.g3:1227:19: ( catchclauses )?
			int alt467 = 2;
			int LA467_0 = this.input.LA(1);

			if ((LA467_0 == CATCH)) {
				alt467 = 1;
			}
			switch (alt467) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: catchclauses
					{
						pushFollow(FOLLOW_catchclauses_in_synpred297_CSharp7900);
						catchclauses();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_finallyclause_in_synpred297_CSharp7903);
			finallyclause();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred297_CSharp

	// $ANTLR start synpred299_CSharp
	public final void synpred299_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1234:9: ( ( specificcatchclauses )? generalcatchclause )
		// ../rsc/CSharp.g3:1234:9: ( specificcatchclauses )? generalcatchclause
		{
			// ../rsc/CSharp.g3:1234:9: ( specificcatchclauses )?
			int alt468 = 2;
			alt468 = this.dfa468.predict(this.input);
			switch (alt468) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: specificcatchclauses
					{
						pushFollow(FOLLOW_specificcatchclauses_in_synpred299_CSharp7979);
						specificcatchclauses();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_generalcatchclause_in_synpred299_CSharp7982);
			generalcatchclause();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred299_CSharp

	// $ANTLR start synpred302_CSharp
	public final void synpred302_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1279:9: ( localvariabledeclaration )
		// ../rsc/CSharp.g3:1279:9: localvariabledeclaration
		{
			pushFollow(FOLLOW_localvariabledeclaration_in_synpred302_CSharp8320);
			localvariabledeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred302_CSharp

	// $ANTLR start synpred318_CSharp
	public final void synpred318_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1358:9: ( ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS )
		// ../rsc/CSharp.g3:1358:10: ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS
		{
			// ../rsc/CSharp.g3:1358:10: ( attributes )?
			int alt469 = 2;
			int LA469_0 = this.input.LA(1);

			if ((LA469_0 == LBRACKET)) {
				alt469 = 1;
			}
			switch (alt469) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred318_CSharp8886);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1358:22: ( classmodifiers )?
			int alt470 = 2;
			int LA470_0 = this.input.LA(1);

			if ((LA470_0 == ABSTRACT || LA470_0 == INTERNAL || LA470_0 == NEW
					|| (LA470_0 >= PRIVATE && LA470_0 <= PUBLIC)
					|| LA470_0 == SEALED || LA470_0 == STATIC)) {
				alt470 = 1;
			}
			switch (alt470) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: classmodifiers
					{
						pushFollow(FOLLOW_classmodifiers_in_synpred318_CSharp8889);
						classmodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1358:38: ( pARTIAL )?
			int alt471 = 2;
			int LA471_0 = this.input.LA(1);

			if ((LA471_0 == PARTIAL)) {
				alt471 = 1;
			}
			switch (alt471) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: pARTIAL
					{
						pushFollow(FOLLOW_pARTIAL_in_synpred318_CSharp8892);
						pARTIAL();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_cLASS_in_synpred318_CSharp8895);
			cLASS();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred318_CSharp

	// $ANTLR start synpred322_CSharp
	public final void synpred322_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1360:9: ( ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT )
		// ../rsc/CSharp.g3:1360:10: ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT
		{
			// ../rsc/CSharp.g3:1360:10: ( attributes )?
			int alt472 = 2;
			int LA472_0 = this.input.LA(1);

			if ((LA472_0 == LBRACKET)) {
				alt472 = 1;
			}
			switch (alt472) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred322_CSharp8923);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1360:22: ( structmodifiers )?
			int alt473 = 2;
			int LA473_0 = this.input.LA(1);

			if ((LA473_0 == INTERNAL || LA473_0 == NEW || (LA473_0 >= PRIVATE && LA473_0 <= PUBLIC))) {
				alt473 = 1;
			}
			switch (alt473) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: structmodifiers
					{
						pushFollow(FOLLOW_structmodifiers_in_synpred322_CSharp8926);
						structmodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1360:39: ( pARTIAL )?
			int alt474 = 2;
			int LA474_0 = this.input.LA(1);

			if ((LA474_0 == PARTIAL)) {
				alt474 = 1;
			}
			switch (alt474) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: pARTIAL
					{
						pushFollow(FOLLOW_pARTIAL_in_synpred322_CSharp8929);
						pARTIAL();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_sTRUCT_in_synpred322_CSharp8932);
			sTRUCT();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred322_CSharp

	// $ANTLR start synpred326_CSharp
	public final void synpred326_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1362:9: ( ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE )
		// ../rsc/CSharp.g3:1362:10: ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE
		{
			// ../rsc/CSharp.g3:1362:10: ( attributes )?
			int alt475 = 2;
			int LA475_0 = this.input.LA(1);

			if ((LA475_0 == LBRACKET)) {
				alt475 = 1;
			}
			switch (alt475) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred326_CSharp8960);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1362:22: ( interfacemodifiers )?
			int alt476 = 2;
			int LA476_0 = this.input.LA(1);

			if ((LA476_0 == INTERNAL || LA476_0 == NEW || (LA476_0 >= PRIVATE && LA476_0 <= PUBLIC))) {
				alt476 = 1;
			}
			switch (alt476) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: interfacemodifiers
					{
						pushFollow(FOLLOW_interfacemodifiers_in_synpred326_CSharp8963);
						interfacemodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1362:42: ( pARTIAL )?
			int alt477 = 2;
			int LA477_0 = this.input.LA(1);

			if ((LA477_0 == PARTIAL)) {
				alt477 = 1;
			}
			switch (alt477) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: pARTIAL
					{
						pushFollow(FOLLOW_pARTIAL_in_synpred326_CSharp8966);
						pARTIAL();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_iNTERFACE_in_synpred326_CSharp8969);
			iNTERFACE();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred326_CSharp

	// $ANTLR start synpred329_CSharp
	public final void synpred329_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1364:9: ( ( attributes )? ( enummodifiers )? eNUM )
		// ../rsc/CSharp.g3:1364:10: ( attributes )? ( enummodifiers )? eNUM
		{
			// ../rsc/CSharp.g3:1364:10: ( attributes )?
			int alt478 = 2;
			int LA478_0 = this.input.LA(1);

			if ((LA478_0 == LBRACKET)) {
				alt478 = 1;
			}
			switch (alt478) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred329_CSharp8997);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1364:22: ( enummodifiers )?
			int alt479 = 2;
			int LA479_0 = this.input.LA(1);

			if ((LA479_0 == INTERNAL || LA479_0 == NEW || (LA479_0 >= PRIVATE && LA479_0 <= PUBLIC))) {
				alt479 = 1;
			}
			switch (alt479) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: enummodifiers
					{
						pushFollow(FOLLOW_enummodifiers_in_synpred329_CSharp9000);
						enummodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_eNUM_in_synpred329_CSharp9003);
			eNUM();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred329_CSharp

	// $ANTLR start synpred332_CSharp
	public final void synpred332_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1366:9: ( ( attributes )? ( delegatemodifiers )? dELEGATE )
		// ../rsc/CSharp.g3:1366:10: ( attributes )? ( delegatemodifiers )? dELEGATE
		{
			// ../rsc/CSharp.g3:1366:10: ( attributes )?
			int alt480 = 2;
			int LA480_0 = this.input.LA(1);

			if ((LA480_0 == LBRACKET)) {
				alt480 = 1;
			}
			switch (alt480) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred332_CSharp9031);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1366:22: ( delegatemodifiers )?
			int alt481 = 2;
			int LA481_0 = this.input.LA(1);

			if ((LA481_0 == INTERNAL || LA481_0 == NEW || (LA481_0 >= PRIVATE && LA481_0 <= PUBLIC))) {
				alt481 = 1;
			}
			switch (alt481) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: delegatemodifiers
					{
						pushFollow(FOLLOW_delegatemodifiers_in_synpred332_CSharp9034);
						delegatemodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_dELEGATE_in_synpred332_CSharp9037);
			dELEGATE();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred332_CSharp

	// $ANTLR start synpred333_CSharp
	public final void synpred333_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1371:49: ( typeargumentlist )
		// ../rsc/CSharp.g3:1371:49: typeargumentlist
		{
			pushFollow(FOLLOW_typeargumentlist_in_synpred333_CSharp9087);
			typeargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred333_CSharp

	// $ANTLR start synpred349_CSharp
	public final void synpred349_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1477:7: ( cOLON classtype cOMMA interfacetypelist )
		// ../rsc/CSharp.g3:1477:7: cOLON classtype cOMMA interfacetypelist
		{
			pushFollow(FOLLOW_cOLON_in_synpred349_CSharp9375);
			cOLON();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_classtype_in_synpred349_CSharp9377);
			classtype();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_cOMMA_in_synpred349_CSharp9379);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_interfacetypelist_in_synpred349_CSharp9381);
			interfacetypelist();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred349_CSharp

	// $ANTLR start synpred354_CSharp
	public final void synpred354_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1502:7: ( ( attributes )? ( constantmodifiers )? cONST )
		// ../rsc/CSharp.g3:1502:8: ( attributes )? ( constantmodifiers )? cONST
		{
			// ../rsc/CSharp.g3:1502:8: ( attributes )?
			int alt482 = 2;
			int LA482_0 = this.input.LA(1);

			if ((LA482_0 == LBRACKET)) {
				alt482 = 1;
			}
			switch (alt482) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred354_CSharp9520);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1502:20: ( constantmodifiers )?
			int alt483 = 2;
			int LA483_0 = this.input.LA(1);

			if ((LA483_0 == INTERNAL || LA483_0 == NEW || (LA483_0 >= PRIVATE && LA483_0 <= PUBLIC))) {
				alt483 = 1;
			}
			switch (alt483) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: constantmodifiers
					{
						pushFollow(FOLLOW_constantmodifiers_in_synpred354_CSharp9523);
						constantmodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_cONST_in_synpred354_CSharp9526);
			cONST();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred354_CSharp

	// $ANTLR start synpred355_CSharp
	public final void synpred355_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1504:9: ( fielddeclaration )
		// ../rsc/CSharp.g3:1504:9: fielddeclaration
		{
			pushFollow(FOLLOW_fielddeclaration_in_synpred355_CSharp9554);
			fielddeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred355_CSharp

	// $ANTLR start synpred356_CSharp
	public final void synpred356_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1506:9: ( methodheader )
		// ../rsc/CSharp.g3:1506:10: methodheader
		{
			pushFollow(FOLLOW_methodheader_in_synpred356_CSharp9577);
			methodheader();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred356_CSharp

	// $ANTLR start synpred357_CSharp
	public final void synpred357_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1508:9: ( propertydeclaration )
		// ../rsc/CSharp.g3:1508:9: propertydeclaration
		{
			pushFollow(FOLLOW_propertydeclaration_in_synpred357_CSharp9604);
			propertydeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred357_CSharp

	// $ANTLR start synpred360_CSharp
	public final void synpred360_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1510:9: ( ( attributes )? ( eventmodifiers )? eVENT )
		// ../rsc/CSharp.g3:1510:10: ( attributes )? ( eventmodifiers )? eVENT
		{
			// ../rsc/CSharp.g3:1510:10: ( attributes )?
			int alt484 = 2;
			int LA484_0 = this.input.LA(1);

			if ((LA484_0 == LBRACKET)) {
				alt484 = 1;
			}
			switch (alt484) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred360_CSharp9627);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1510:22: ( eventmodifiers )?
			int alt485 = 2;
			int LA485_0 = this.input.LA(1);

			if ((LA485_0 == ABSTRACT || LA485_0 == EXTERN
					|| LA485_0 == INTERNAL || LA485_0 == NEW
					|| LA485_0 == OVERRIDE
					|| (LA485_0 >= PRIVATE && LA485_0 <= PUBLIC)
					|| LA485_0 == SEALED || LA485_0 == STATIC || LA485_0 == VIRTUAL)) {
				alt485 = 1;
			}
			switch (alt485) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: eventmodifiers
					{
						pushFollow(FOLLOW_eventmodifiers_in_synpred360_CSharp9630);
						eventmodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_eVENT_in_synpred360_CSharp9633);
			eVENT();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred360_CSharp

	// $ANTLR start synpred363_CSharp
	public final void synpred363_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1512:9: ( ( attributes )? ( indexermodifiers )? indexerdeclarator )
		// ../rsc/CSharp.g3:1512:10: ( attributes )? ( indexermodifiers )? indexerdeclarator
		{
			// ../rsc/CSharp.g3:1512:10: ( attributes )?
			int alt486 = 2;
			int LA486_0 = this.input.LA(1);

			if ((LA486_0 == LBRACKET)) {
				alt486 = 1;
			}
			switch (alt486) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred363_CSharp9661);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1512:22: ( indexermodifiers )?
			int alt487 = 2;
			int LA487_0 = this.input.LA(1);

			if ((LA487_0 == ABSTRACT || LA487_0 == EXTERN
					|| LA487_0 == INTERNAL || LA487_0 == NEW
					|| LA487_0 == OVERRIDE
					|| (LA487_0 >= PRIVATE && LA487_0 <= PUBLIC)
					|| LA487_0 == SEALED || LA487_0 == VIRTUAL)) {
				alt487 = 1;
			}
			switch (alt487) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: indexermodifiers
					{
						pushFollow(FOLLOW_indexermodifiers_in_synpred363_CSharp9664);
						indexermodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_indexerdeclarator_in_synpred363_CSharp9667);
			indexerdeclarator();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred363_CSharp

	// $ANTLR start synpred365_CSharp
	public final void synpred365_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1514:9: ( ( attributes )? operatormodifiers operatordeclarator )
		// ../rsc/CSharp.g3:1514:10: ( attributes )? operatormodifiers operatordeclarator
		{
			// ../rsc/CSharp.g3:1514:10: ( attributes )?
			int alt488 = 2;
			int LA488_0 = this.input.LA(1);

			if ((LA488_0 == LBRACKET)) {
				alt488 = 1;
			}
			switch (alt488) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred365_CSharp9695);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_operatormodifiers_in_synpred365_CSharp9698);
			operatormodifiers();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_operatordeclarator_in_synpred365_CSharp9700);
			operatordeclarator();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred365_CSharp

	// $ANTLR start synpred368_CSharp
	public final void synpred368_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1516:9: ( ( attributes )? ( constructormodifiers )? constructordeclarator )
		// ../rsc/CSharp.g3:1516:10: ( attributes )? ( constructormodifiers )? constructordeclarator
		{
			// ../rsc/CSharp.g3:1516:10: ( attributes )?
			int alt489 = 2;
			int LA489_0 = this.input.LA(1);

			if ((LA489_0 == LBRACKET)) {
				alt489 = 1;
			}
			switch (alt489) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred368_CSharp9728);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1516:22: ( constructormodifiers )?
			int alt490 = 2;
			int LA490_0 = this.input.LA(1);

			if ((LA490_0 == EXTERN || LA490_0 == INTERNAL || (LA490_0 >= PRIVATE && LA490_0 <= PUBLIC))) {
				alt490 = 1;
			}
			switch (alt490) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: constructormodifiers
					{
						pushFollow(FOLLOW_constructormodifiers_in_synpred368_CSharp9731);
						constructormodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_constructordeclarator_in_synpred368_CSharp9734);
			constructordeclarator();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred368_CSharp

	// $ANTLR start synpred371_CSharp
	public final void synpred371_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1518:9: ( ( attributes )? ( eXTERN )? tILDE )
		// ../rsc/CSharp.g3:1518:10: ( attributes )? ( eXTERN )? tILDE
		{
			// ../rsc/CSharp.g3:1518:10: ( attributes )?
			int alt491 = 2;
			int LA491_0 = this.input.LA(1);

			if ((LA491_0 == LBRACKET)) {
				alt491 = 1;
			}
			switch (alt491) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred371_CSharp9762);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1518:22: ( eXTERN )?
			int alt492 = 2;
			int LA492_0 = this.input.LA(1);

			if ((LA492_0 == EXTERN)) {
				alt492 = 1;
			}
			switch (alt492) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: eXTERN
					{
						pushFollow(FOLLOW_eXTERN_in_synpred371_CSharp9765);
						eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_tILDE_in_synpred371_CSharp9768);
			tILDE();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred371_CSharp

	// $ANTLR start synpred373_CSharp
	public final void synpred373_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1520:9: ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )
		// ../rsc/CSharp.g3:1520:10: ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN
		{
			// ../rsc/CSharp.g3:1520:10: ( attributes )?
			int alt493 = 2;
			int LA493_0 = this.input.LA(1);

			if ((LA493_0 == LBRACKET)) {
				alt493 = 1;
			}
			switch (alt493) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred373_CSharp9796);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_staticconstructormodifiers_in_synpred373_CSharp9799);
			staticconstructormodifiers();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_identifier_in_synpred373_CSharp9801);
			identifier();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_lPAREN_in_synpred373_CSharp9803);
			lPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_rPAREN_in_synpred373_CSharp9805);
			rPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred373_CSharp

	// $ANTLR start synpred413_CSharp
	public final void synpred413_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1829:9: ( fixedparameters cOMMA parameterarray )
		// ../rsc/CSharp.g3:1829:9: fixedparameters cOMMA parameterarray
		{
			pushFollow(FOLLOW_fixedparameters_in_synpred413_CSharp11068);
			fixedparameters();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_cOMMA_in_synpred413_CSharp11070);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_parameterarray_in_synpred413_CSharp11072);
			parameterarray();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred413_CSharp

	// $ANTLR start synpred414_CSharp
	public final void synpred414_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1831:9: ( fixedparameters )
		// ../rsc/CSharp.g3:1831:9: fixedparameters
		{
			pushFollow(FOLLOW_fixedparameters_in_synpred414_CSharp11089);
			fixedparameters();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred414_CSharp

	// $ANTLR start synpred415_CSharp
	public final void synpred415_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1842:7: ( cOMMA f2= fixedparameter )
		// ../rsc/CSharp.g3:1842:7: cOMMA f2= fixedparameter
		{
			pushFollow(FOLLOW_cOMMA_in_synpred415_CSharp11154);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_fixedparameter_in_synpred415_CSharp11158);
			fixedparameter();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred415_CSharp

	// $ANTLR start synpred434_CSharp
	public final void synpred434_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1904:9: ( getaccessordeclaration ( setaccessordeclaration )? )
		// ../rsc/CSharp.g3:1904:9: getaccessordeclaration ( setaccessordeclaration )?
		{
			pushFollow(FOLLOW_getaccessordeclaration_in_synpred434_CSharp11586);
			getaccessordeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;
			// ../rsc/CSharp.g3:1904:32: ( setaccessordeclaration )?
			int alt494 = 2;
			int LA494_0 = this.input.LA(1);

			if ((LA494_0 == LBRACKET || LA494_0 == INTERNAL
					|| (LA494_0 >= PRIVATE && LA494_0 <= PROTECTED) || LA494_0 == SET)) {
				alt494 = 1;
			}
			switch (alt494) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: setaccessordeclaration
					{
						pushFollow(FOLLOW_setaccessordeclaration_in_synpred434_CSharp11588);
						setaccessordeclaration();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

		}
	}
	// $ANTLR end synpred434_CSharp

	// $ANTLR start synpred447_CSharp
	public final void synpred447_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1935:9: ( ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON )
		// ../rsc/CSharp.g3:1935:9: ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON
		{
			// ../rsc/CSharp.g3:1935:9: ( attributes )?
			int alt495 = 2;
			int LA495_0 = this.input.LA(1);

			if ((LA495_0 == LBRACKET)) {
				alt495 = 1;
			}
			switch (alt495) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred447_CSharp11871);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:1935:21: ( eventmodifiers )?
			int alt496 = 2;
			int LA496_0 = this.input.LA(1);

			if ((LA496_0 == ABSTRACT || LA496_0 == EXTERN
					|| LA496_0 == INTERNAL || LA496_0 == NEW
					|| LA496_0 == OVERRIDE
					|| (LA496_0 >= PRIVATE && LA496_0 <= PUBLIC)
					|| LA496_0 == SEALED || LA496_0 == STATIC || LA496_0 == VIRTUAL)) {
				alt496 = 1;
			}
			switch (alt496) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: eventmodifiers
					{
						pushFollow(FOLLOW_eventmodifiers_in_synpred447_CSharp11874);
						eventmodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_eVENT_in_synpred447_CSharp11877);
			eVENT();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_type_in_synpred447_CSharp11879);
			type();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_variabledeclarators_in_synpred447_CSharp11881);
			variabledeclarators();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_sEMICOLON_in_synpred447_CSharp11883);
			sEMICOLON();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred447_CSharp

	// $ANTLR start synpred461_CSharp
	public final void synpred461_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:1966:9: ( addaccessordeclaration removeaccessordeclaration )
		// ../rsc/CSharp.g3:1966:9: addaccessordeclaration removeaccessordeclaration
		{
			pushFollow(FOLLOW_addaccessordeclaration_in_synpred461_CSharp12158);
			addaccessordeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_removeaccessordeclaration_in_synpred461_CSharp12160);
			removeaccessordeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred461_CSharp

	// $ANTLR start synpred481_CSharp
	public final void synpred481_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2054:9: ( unaryoperatordeclarator )
		// ../rsc/CSharp.g3:2054:9: unaryoperatordeclarator
		{
			pushFollow(FOLLOW_unaryoperatordeclarator_in_synpred481_CSharp12706);
			unaryoperatordeclarator();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred481_CSharp

	// $ANTLR start synpred482_CSharp
	public final void synpred482_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2057:9: ( binaryoperatordeclarator )
		// ../rsc/CSharp.g3:2057:9: binaryoperatordeclarator
		{
			pushFollow(FOLLOW_binaryoperatordeclarator_in_synpred482_CSharp12735);
			binaryoperatordeclarator();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred482_CSharp

	// $ANTLR start synpred521_CSharp
	public final void synpred521_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2180:9: ( ( eXTERN )? sTATIC )
		// ../rsc/CSharp.g3:2180:9: ( eXTERN )? sTATIC
		{
			// ../rsc/CSharp.g3:2180:9: ( eXTERN )?
			int alt498 = 2;
			int LA498_0 = this.input.LA(1);

			if ((LA498_0 == EXTERN)) {
				alt498 = 1;
			}
			switch (alt498) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: eXTERN
					{
						pushFollow(FOLLOW_eXTERN_in_synpred521_CSharp13858);
						eXTERN();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_sTATIC_in_synpred521_CSharp13861);
			sTATIC();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred521_CSharp

	// $ANTLR start synpred542_CSharp
	public final void synpred542_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2244:7: ( ( attributes )? ( constantmodifiers )? cONST )
		// ../rsc/CSharp.g3:2244:8: ( attributes )? ( constantmodifiers )? cONST
		{
			// ../rsc/CSharp.g3:2244:8: ( attributes )?
			int alt499 = 2;
			int LA499_0 = this.input.LA(1);

			if ((LA499_0 == LBRACKET)) {
				alt499 = 1;
			}
			switch (alt499) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred542_CSharp14335);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:2244:20: ( constantmodifiers )?
			int alt500 = 2;
			int LA500_0 = this.input.LA(1);

			if ((LA500_0 == INTERNAL || LA500_0 == NEW || (LA500_0 >= PRIVATE && LA500_0 <= PUBLIC))) {
				alt500 = 1;
			}
			switch (alt500) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: constantmodifiers
					{
						pushFollow(FOLLOW_constantmodifiers_in_synpred542_CSharp14338);
						constantmodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_cONST_in_synpred542_CSharp14341);
			cONST();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred542_CSharp

	// $ANTLR start synpred543_CSharp
	public final void synpred543_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2246:9: ( fielddeclaration )
		// ../rsc/CSharp.g3:2246:9: fielddeclaration
		{
			pushFollow(FOLLOW_fielddeclaration_in_synpred543_CSharp14369);
			fielddeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred543_CSharp

	// $ANTLR start synpred544_CSharp
	public final void synpred544_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2248:9: ( methodheader )
		// ../rsc/CSharp.g3:2248:10: methodheader
		{
			pushFollow(FOLLOW_methodheader_in_synpred544_CSharp14392);
			methodheader();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred544_CSharp

	// $ANTLR start synpred545_CSharp
	public final void synpred545_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2250:9: ( propertydeclaration )
		// ../rsc/CSharp.g3:2250:9: propertydeclaration
		{
			pushFollow(FOLLOW_propertydeclaration_in_synpred545_CSharp14419);
			propertydeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred545_CSharp

	// $ANTLR start synpred548_CSharp
	public final void synpred548_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2252:9: ( ( attributes )? ( eventmodifiers )? eVENT )
		// ../rsc/CSharp.g3:2252:10: ( attributes )? ( eventmodifiers )? eVENT
		{
			// ../rsc/CSharp.g3:2252:10: ( attributes )?
			int alt501 = 2;
			int LA501_0 = this.input.LA(1);

			if ((LA501_0 == LBRACKET)) {
				alt501 = 1;
			}
			switch (alt501) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred548_CSharp14442);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:2252:22: ( eventmodifiers )?
			int alt502 = 2;
			int LA502_0 = this.input.LA(1);

			if ((LA502_0 == ABSTRACT || LA502_0 == EXTERN
					|| LA502_0 == INTERNAL || LA502_0 == NEW
					|| LA502_0 == OVERRIDE
					|| (LA502_0 >= PRIVATE && LA502_0 <= PUBLIC)
					|| LA502_0 == SEALED || LA502_0 == STATIC || LA502_0 == VIRTUAL)) {
				alt502 = 1;
			}
			switch (alt502) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: eventmodifiers
					{
						pushFollow(FOLLOW_eventmodifiers_in_synpred548_CSharp14445);
						eventmodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_eVENT_in_synpred548_CSharp14448);
			eVENT();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred548_CSharp

	// $ANTLR start synpred551_CSharp
	public final void synpred551_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2254:9: ( ( attributes )? ( indexermodifiers )? indexerdeclarator )
		// ../rsc/CSharp.g3:2254:10: ( attributes )? ( indexermodifiers )? indexerdeclarator
		{
			// ../rsc/CSharp.g3:2254:10: ( attributes )?
			int alt503 = 2;
			int LA503_0 = this.input.LA(1);

			if ((LA503_0 == LBRACKET)) {
				alt503 = 1;
			}
			switch (alt503) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred551_CSharp14476);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:2254:22: ( indexermodifiers )?
			int alt504 = 2;
			int LA504_0 = this.input.LA(1);

			if ((LA504_0 == ABSTRACT || LA504_0 == EXTERN
					|| LA504_0 == INTERNAL || LA504_0 == NEW
					|| LA504_0 == OVERRIDE
					|| (LA504_0 >= PRIVATE && LA504_0 <= PUBLIC)
					|| LA504_0 == SEALED || LA504_0 == VIRTUAL)) {
				alt504 = 1;
			}
			switch (alt504) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: indexermodifiers
					{
						pushFollow(FOLLOW_indexermodifiers_in_synpred551_CSharp14479);
						indexermodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_indexerdeclarator_in_synpred551_CSharp14482);
			indexerdeclarator();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred551_CSharp

	// $ANTLR start synpred553_CSharp
	public final void synpred553_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2256:9: ( ( attributes )? operatormodifiers operatordeclarator )
		// ../rsc/CSharp.g3:2256:10: ( attributes )? operatormodifiers operatordeclarator
		{
			// ../rsc/CSharp.g3:2256:10: ( attributes )?
			int alt505 = 2;
			int LA505_0 = this.input.LA(1);

			if ((LA505_0 == LBRACKET)) {
				alt505 = 1;
			}
			switch (alt505) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred553_CSharp14510);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_operatormodifiers_in_synpred553_CSharp14513);
			operatormodifiers();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_operatordeclarator_in_synpred553_CSharp14515);
			operatordeclarator();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred553_CSharp

	// $ANTLR start synpred556_CSharp
	public final void synpred556_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2258:9: ( ( attributes )? ( constructormodifiers )? constructordeclarator )
		// ../rsc/CSharp.g3:2258:10: ( attributes )? ( constructormodifiers )? constructordeclarator
		{
			// ../rsc/CSharp.g3:2258:10: ( attributes )?
			int alt506 = 2;
			int LA506_0 = this.input.LA(1);

			if ((LA506_0 == LBRACKET)) {
				alt506 = 1;
			}
			switch (alt506) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred556_CSharp14543);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			// ../rsc/CSharp.g3:2258:22: ( constructormodifiers )?
			int alt507 = 2;
			int LA507_0 = this.input.LA(1);

			if ((LA507_0 == EXTERN || LA507_0 == INTERNAL || (LA507_0 >= PRIVATE && LA507_0 <= PUBLIC))) {
				alt507 = 1;
			}
			switch (alt507) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: constructormodifiers
					{
						pushFollow(FOLLOW_constructormodifiers_in_synpred556_CSharp14546);
						constructormodifiers();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_constructordeclarator_in_synpred556_CSharp14549);
			constructordeclarator();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred556_CSharp

	// $ANTLR start synpred558_CSharp
	public final void synpred558_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2260:9: ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )
		// ../rsc/CSharp.g3:2260:10: ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN
		{
			// ../rsc/CSharp.g3:2260:10: ( attributes )?
			int alt508 = 2;
			int LA508_0 = this.input.LA(1);

			if ((LA508_0 == LBRACKET)) {
				alt508 = 1;
			}
			switch (alt508) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred558_CSharp14577);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_staticconstructormodifiers_in_synpred558_CSharp14580);
			staticconstructormodifiers();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_identifier_in_synpred558_CSharp14582);
			identifier();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_lPAREN_in_synpred558_CSharp14584);
			lPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_rPAREN_in_synpred558_CSharp14586);
			rPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred558_CSharp

	// $ANTLR start synpred559_CSharp
	public final void synpred559_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2274:9: ( valuetype )
		// ../rsc/CSharp.g3:2274:9: valuetype
		{
			pushFollow(FOLLOW_valuetype_in_synpred559_CSharp14692);
			valuetype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred559_CSharp

	// $ANTLR start synpred560_CSharp
	public final void synpred560_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2276:9: ( classtype )
		// ../rsc/CSharp.g3:2276:9: classtype
		{
			pushFollow(FOLLOW_classtype_in_synpred560_CSharp14705);
			classtype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred560_CSharp

	// $ANTLR start synpred561_CSharp
	public final void synpred561_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2278:9: ( interfacetype )
		// ../rsc/CSharp.g3:2278:9: interfacetype
		{
			pushFollow(FOLLOW_interfacetype_in_synpred561_CSharp14718);
			interfacetype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred561_CSharp

	// $ANTLR start synpred562_CSharp
	public final void synpred562_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2280:9: ( delegatetype )
		// ../rsc/CSharp.g3:2280:9: delegatetype
		{
			pushFollow(FOLLOW_delegatetype_in_synpred562_CSharp14731);
			delegatetype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred562_CSharp

	// $ANTLR start synpred567_CSharp
	public final void synpred567_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2312:9: ( lBRACE ( variableinitializerlist )? rBRACE )
		// ../rsc/CSharp.g3:2312:9: lBRACE ( variableinitializerlist )? rBRACE
		{
			pushFollow(FOLLOW_lBRACE_in_synpred567_CSharp14905);
			lBRACE();

			this.state._fsp--;
			if (this.state.failed)
				return;
			// ../rsc/CSharp.g3:2312:16: ( variableinitializerlist )?
			int alt509 = 2;
			int LA509_0 = this.input.LA(1);

			if ((LA509_0 == LBRACE || LA509_0 == LPAREN
					|| (LA509_0 >= PLUS && LA509_0 <= MINUS)
					|| (LA509_0 >= EXCLAM && LA509_0 <= TILDE)
					|| (LA509_0 >= INCREMENT && LA509_0 <= DECREMENT)
					|| (LA509_0 >= BASE && LA509_0 <= BOOL) || LA509_0 == BYTE
					|| (LA509_0 >= CHAR && LA509_0 <= CHECKED)
					|| (LA509_0 >= DECIMAL && LA509_0 <= DELEGATE)
					|| LA509_0 == DOUBLE || LA509_0 == FALSE
					|| LA509_0 == FLOAT || LA509_0 == INT || LA509_0 == LONG
					|| (LA509_0 >= NEW && LA509_0 <= OBJECT)
					|| LA509_0 == SBYTE || LA509_0 == SHORT
					|| LA509_0 == STRING || LA509_0 == THIS || LA509_0 == TRUE
					|| (LA509_0 >= TYPEOF && LA509_0 <= UNCHECKED)
					|| LA509_0 == USHORT || (LA509_0 >= ADD && LA509_0 <= Stringliteral))) {
				alt509 = 1;
			}
			switch (alt509) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: variableinitializerlist
					{
						pushFollow(FOLLOW_variableinitializerlist_in_synpred567_CSharp14907);
						variableinitializerlist();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_rBRACE_in_synpred567_CSharp14910);
			rBRACE();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred567_CSharp

	// $ANTLR start synpred583_CSharp
	public final void synpred583_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2388:9: ( interfacemethoddeclaration )
		// ../rsc/CSharp.g3:2388:9: interfacemethoddeclaration
		{
			pushFollow(FOLLOW_interfacemethoddeclaration_in_synpred583_CSharp15312);
			interfacemethoddeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred583_CSharp

	// $ANTLR start synpred584_CSharp
	public final void synpred584_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2390:9: ( interfacepropertydeclaration )
		// ../rsc/CSharp.g3:2390:9: interfacepropertydeclaration
		{
			pushFollow(FOLLOW_interfacepropertydeclaration_in_synpred584_CSharp15334);
			interfacepropertydeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred584_CSharp

	// $ANTLR start synpred585_CSharp
	public final void synpred585_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2392:9: ( interfaceeventdeclaration )
		// ../rsc/CSharp.g3:2392:9: interfaceeventdeclaration
		{
			pushFollow(FOLLOW_interfaceeventdeclaration_in_synpred585_CSharp15356);
			interfaceeventdeclaration();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred585_CSharp

	// $ANTLR start synpred596_CSharp
	public final void synpred596_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2427:9: ( ( attributes )? gET sEMICOLON ( ( attributes )? sET sEMICOLON )? )
		// ../rsc/CSharp.g3:2427:9: ( attributes )? gET sEMICOLON ( ( attributes )? sET sEMICOLON )?
		{
			// ../rsc/CSharp.g3:2427:9: ( attributes )?
			int alt511 = 2;
			int LA511_0 = this.input.LA(1);

			if ((LA511_0 == LBRACKET)) {
				alt511 = 1;
			}
			switch (alt511) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred596_CSharp15634);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_gET_in_synpred596_CSharp15637);
			gET();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_sEMICOLON_in_synpred596_CSharp15639);
			sEMICOLON();

			this.state._fsp--;
			if (this.state.failed)
				return;
			// ../rsc/CSharp.g3:2427:35: ( ( attributes )? sET sEMICOLON )?
			int alt513 = 2;
			int LA513_0 = this.input.LA(1);

			if ((LA513_0 == LBRACKET || LA513_0 == SET)) {
				alt513 = 1;
			}
			switch (alt513) {
				case 1 :
				// ../rsc/CSharp.g3:2427:36: ( attributes )? sET sEMICOLON
					{
						// ../rsc/CSharp.g3:2427:36: ( attributes )?
						int alt512 = 2;
						int LA512_0 = this.input.LA(1);

						if ((LA512_0 == LBRACKET)) {
							alt512 = 1;
						}
						switch (alt512) {
							case 1 :
							// ../rsc/CSharp.g3:0:0: attributes
								{
									pushFollow(FOLLOW_attributes_in_synpred596_CSharp15642);
									attributes();

									this.state._fsp--;
									if (this.state.failed)
										return;

								}
								break;

						}

						pushFollow(FOLLOW_sET_in_synpred596_CSharp15645);
						sET();

						this.state._fsp--;
						if (this.state.failed)
							return;
						pushFollow(FOLLOW_sEMICOLON_in_synpred596_CSharp15647);
						sEMICOLON();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

		}
	}
	// $ANTLR end synpred596_CSharp

	// $ANTLR start synpred609_CSharp
	public final void synpred609_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2469:9: ( lBRACE ( enummemberdeclarations )? rBRACE )
		// ../rsc/CSharp.g3:2469:9: lBRACE ( enummemberdeclarations )? rBRACE
		{
			pushFollow(FOLLOW_lBRACE_in_synpred609_CSharp16043);
			lBRACE();

			this.state._fsp--;
			if (this.state.failed)
				return;
			// ../rsc/CSharp.g3:2469:16: ( enummemberdeclarations )?
			int alt515 = 2;
			int LA515_0 = this.input.LA(1);

			if ((LA515_0 == LBRACKET || (LA515_0 >= ADD && LA515_0 <= Ident))) {
				alt515 = 1;
			}
			switch (alt515) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: enummemberdeclarations
					{
						pushFollow(FOLLOW_enummemberdeclarations_in_synpred609_CSharp16045);
						enummemberdeclarations();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_rBRACE_in_synpred609_CSharp16048);
			rBRACE();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred609_CSharp

	// $ANTLR start synpred617_CSharp
	public final void synpred617_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2493:7: ( ( attributes )? identifier aSSIGN constantexpression )
		// ../rsc/CSharp.g3:2493:7: ( attributes )? identifier aSSIGN constantexpression
		{
			// ../rsc/CSharp.g3:2493:7: ( attributes )?
			int alt516 = 2;
			int LA516_0 = this.input.LA(1);

			if ((LA516_0 == LBRACKET)) {
				alt516 = 1;
			}
			switch (alt516) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: attributes
					{
						pushFollow(FOLLOW_attributes_in_synpred617_CSharp16238);
						attributes();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_identifier_in_synpred617_CSharp16241);
			identifier();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_aSSIGN_in_synpred617_CSharp16243);
			aSSIGN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_constantexpression_in_synpred617_CSharp16245);
			constantexpression();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred617_CSharp

	// $ANTLR start synpred629_CSharp
	public final void synpred629_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2526:9: ( globalattributesection )
		// ../rsc/CSharp.g3:2526:9: globalattributesection
		{
			pushFollow(FOLLOW_globalattributesection_in_synpred629_CSharp16512);
			globalattributesection();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred629_CSharp

	// $ANTLR start synpred630_CSharp
	public final void synpred630_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2533:9: ( lBRACKET globalattributetargetspecifier attributelist rBRACKET )
		// ../rsc/CSharp.g3:2533:9: lBRACKET globalattributetargetspecifier attributelist rBRACKET
		{
			pushFollow(FOLLOW_lBRACKET_in_synpred630_CSharp16547);
			lBRACKET();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_globalattributetargetspecifier_in_synpred630_CSharp16549);
			globalattributetargetspecifier();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_attributelist_in_synpred630_CSharp16551);
			attributelist();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_rBRACKET_in_synpred630_CSharp16553);
			rBRACKET();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred630_CSharp

	// $ANTLR start synpred639_CSharp
	public final void synpred639_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2587:9: ( lPAREN ( positionalargumentlist )? rPAREN )
		// ../rsc/CSharp.g3:2587:9: lPAREN ( positionalargumentlist )? rPAREN
		{
			pushFollow(FOLLOW_lPAREN_in_synpred639_CSharp16939);
			lPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			// ../rsc/CSharp.g3:2587:16: ( positionalargumentlist )?
			int alt517 = 2;
			int LA517_0 = this.input.LA(1);

			if ((LA517_0 == LPAREN || (LA517_0 >= PLUS && LA517_0 <= MINUS)
					|| (LA517_0 >= EXCLAM && LA517_0 <= TILDE)
					|| (LA517_0 >= INCREMENT && LA517_0 <= DECREMENT)
					|| (LA517_0 >= BASE && LA517_0 <= BOOL) || LA517_0 == BYTE
					|| (LA517_0 >= CHAR && LA517_0 <= CHECKED)
					|| (LA517_0 >= DECIMAL && LA517_0 <= DELEGATE)
					|| LA517_0 == DOUBLE || LA517_0 == FALSE
					|| LA517_0 == FLOAT || LA517_0 == INT || LA517_0 == LONG
					|| (LA517_0 >= NEW && LA517_0 <= OBJECT)
					|| LA517_0 == SBYTE || LA517_0 == SHORT
					|| LA517_0 == STRING || LA517_0 == THIS || LA517_0 == TRUE
					|| (LA517_0 >= TYPEOF && LA517_0 <= UNCHECKED)
					|| LA517_0 == USHORT || (LA517_0 >= ADD && LA517_0 <= Stringliteral))) {
				alt517 = 1;
			}
			switch (alt517) {
				case 1 :
				// ../rsc/CSharp.g3:0:0: positionalargumentlist
					{
						pushFollow(FOLLOW_positionalargumentlist_in_synpred639_CSharp16941);
						positionalargumentlist();

						this.state._fsp--;
						if (this.state.failed)
							return;

					}
					break;

			}

			pushFollow(FOLLOW_rPAREN_in_synpred639_CSharp16944);
			rPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred639_CSharp

	// $ANTLR start synpred640_CSharp
	public final void synpred640_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2589:9: ( lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN )
		// ../rsc/CSharp.g3:2589:9: lPAREN positionalargumentlist cOMMA namedargumentlist rPAREN
		{
			pushFollow(FOLLOW_lPAREN_in_synpred640_CSharp16971);
			lPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_positionalargumentlist_in_synpred640_CSharp16973);
			positionalargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_cOMMA_in_synpred640_CSharp16975);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_namedargumentlist_in_synpred640_CSharp16977);
			namedargumentlist();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_rPAREN_in_synpred640_CSharp16979);
			rPAREN();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred640_CSharp

	// $ANTLR start synpred641_CSharp
	public final void synpred641_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2596:29: ( cOMMA positionalargument )
		// ../rsc/CSharp.g3:2596:29: cOMMA positionalargument
		{
			pushFollow(FOLLOW_cOMMA_in_synpred641_CSharp17052);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_positionalargument_in_synpred641_CSharp17054);
			positionalargument();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred641_CSharp

	// $ANTLR start synpred647_CSharp
	public final void synpred647_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2672:9: ( primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint )
		// ../rsc/CSharp.g3:2672:9: primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint
		{
			pushFollow(FOLLOW_primaryconstraint_in_synpred647_CSharp17524);
			primaryconstraint();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_cOMMA_in_synpred647_CSharp17526);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_secondaryconstraints_in_synpred647_CSharp17528);
			secondaryconstraints();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_cOMMA_in_synpred647_CSharp17530);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_constructorconstraint_in_synpred647_CSharp17532);
			constructorconstraint();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred647_CSharp

	// $ANTLR start synpred648_CSharp
	public final void synpred648_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2674:9: ( primaryconstraint cOMMA secondaryconstraints )
		// ../rsc/CSharp.g3:2674:9: primaryconstraint cOMMA secondaryconstraints
		{
			pushFollow(FOLLOW_primaryconstraint_in_synpred648_CSharp17562);
			primaryconstraint();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_cOMMA_in_synpred648_CSharp17564);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_secondaryconstraints_in_synpred648_CSharp17566);
			secondaryconstraints();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred648_CSharp

	// $ANTLR start synpred649_CSharp
	public final void synpred649_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2676:9: ( primaryconstraint cOMMA constructorconstraint )
		// ../rsc/CSharp.g3:2676:9: primaryconstraint cOMMA constructorconstraint
		{
			pushFollow(FOLLOW_primaryconstraint_in_synpred649_CSharp17592);
			primaryconstraint();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_cOMMA_in_synpred649_CSharp17594);
			cOMMA();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_constructorconstraint_in_synpred649_CSharp17596);
			constructorconstraint();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred649_CSharp

	// $ANTLR start synpred650_CSharp
	public final void synpred650_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2680:7: ( primaryconstraint )
		// ../rsc/CSharp.g3:2680:7: primaryconstraint
		{
			pushFollow(FOLLOW_primaryconstraint_in_synpred650_CSharp17622);
			primaryconstraint();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred650_CSharp

	// $ANTLR start synpred653_CSharp
	public final void synpred653_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2698:9: ( interfacetype secondaryconstraintsrest )
		// ../rsc/CSharp.g3:2698:9: interfacetype secondaryconstraintsrest
		{
			pushFollow(FOLLOW_interfacetype_in_synpred653_CSharp17752);
			interfacetype();

			this.state._fsp--;
			if (this.state.failed)
				return;
			pushFollow(FOLLOW_secondaryconstraintsrest_in_synpred653_CSharp17754);
			secondaryconstraintsrest();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred653_CSharp

	// $ANTLR start synpred654_CSharp
	public final void synpred654_CSharp_fragment() throws RecognitionException {
		// ../rsc/CSharp.g3:2705:12: ( interfacetype )
		// ../rsc/CSharp.g3:2705:12: interfacetype
		{
			pushFollow(FOLLOW_interfacetype_in_synpred654_CSharp17804);
			interfacetype();

			this.state._fsp--;
			if (this.state.failed)
				return;

		}
	}
	// $ANTLR end synpred654_CSharp

	// Delegated rules

	public final boolean synpred447_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred447_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred434_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred434_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred190_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred190_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred209_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred209_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred542_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred542_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred357_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred357_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred112_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred112_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred544_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred544_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred553_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred553_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred630_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred630_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred96_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred96_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred560_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred560_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred354_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred354_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred123_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred123_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred461_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred461_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred558_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred558_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred195_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred195_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred368_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred368_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred271_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred271_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred299_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred299_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred297_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred297_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred559_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred559_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred113_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred113_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred371_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred371_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred333_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred333_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred363_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred363_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred131_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred131_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred136_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred136_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred187_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred187_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred567_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred567_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred482_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred482_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred192_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred192_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred125_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred125_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred562_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred562_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred647_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred647_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred272_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred272_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred650_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred650_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred127_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred127_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred585_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred585_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred640_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred640_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred133_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred133_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred302_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred302_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred97_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred97_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred561_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred561_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred115_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred115_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred596_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred596_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred629_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred629_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred329_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred329_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred275_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred275_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred641_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred641_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred99_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred99_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred95_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred95_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred648_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred648_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred653_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred653_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred365_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred365_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred521_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred521_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred639_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred639_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred92_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred92_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred249_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred249_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred318_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred318_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred124_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred124_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred548_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred548_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred556_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred556_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred355_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred355_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred149_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred149_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred649_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred649_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred143_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred143_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred88_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred88_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred248_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred248_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred268_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred268_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred194_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred194_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred414_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred414_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred250_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred250_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred270_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred270_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred326_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred326_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred356_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred356_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred543_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred543_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred545_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred545_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred373_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred373_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred126_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred126_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred269_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred269_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred286_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred286_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred128_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred128_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred360_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred360_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred273_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred273_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred413_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred413_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred609_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred609_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred90_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred90_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred332_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred332_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred141_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred141_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred210_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred210_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred584_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred584_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred129_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred129_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred171_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred171_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred322_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred322_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred91_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred91_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred116_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred116_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred583_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred583_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred481_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred481_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred98_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred98_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred415_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred415_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred551_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred551_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred349_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred349_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred617_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred617_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred654_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred654_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred93_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred93_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}
	public final boolean synpred122_CSharp() {
		this.state.backtracking++;
		int start = this.input.mark();
		try {
			synpred122_CSharp_fragment(); // can never throw exception
		}
		catch (RecognitionException re) {
			System.err.println("impossible: " + re);
		}
		boolean success = !this.state.failed;
		this.input.rewind(start);
		this.state.backtracking--;
		this.state.failed = false;
		return success;
	}

	protected DFA1 dfa1 = new DFA1(this);
	protected DFA2 dfa2 = new DFA2(this);
	protected DFA6 dfa6 = new DFA6(this);
	protected DFA10 dfa10 = new DFA10(this);
	protected DFA8 dfa8 = new DFA8(this);
	protected DFA9 dfa9 = new DFA9(this);
	protected DFA12 dfa12 = new DFA12(this);
	protected DFA11 dfa11 = new DFA11(this);
	protected DFA13 dfa13 = new DFA13(this);
	protected DFA14 dfa14 = new DFA14(this);
	protected DFA15 dfa15 = new DFA15(this);
	protected DFA18 dfa18 = new DFA18(this);
	protected DFA20 dfa20 = new DFA20(this);
	protected DFA21 dfa21 = new DFA21(this);
	protected DFA25 dfa25 = new DFA25(this);
	protected DFA26 dfa26 = new DFA26(this);
	protected DFA27 dfa27 = new DFA27(this);
	protected DFA28 dfa28 = new DFA28(this);
	protected DFA29 dfa29 = new DFA29(this);
	protected DFA30 dfa30 = new DFA30(this);
	protected DFA34 dfa34 = new DFA34(this);
	protected DFA44 dfa44 = new DFA44(this);
	protected DFA45 dfa45 = new DFA45(this);
	protected DFA48 dfa48 = new DFA48(this);
	protected DFA47 dfa47 = new DFA47(this);
	protected DFA53 dfa53 = new DFA53(this);
	protected DFA54 dfa54 = new DFA54(this);
	protected DFA61 dfa61 = new DFA61(this);
	protected DFA68 dfa68 = new DFA68(this);
	protected DFA82 dfa82 = new DFA82(this);
	protected DFA83 dfa83 = new DFA83(this);
	protected DFA84 dfa84 = new DFA84(this);
	protected DFA86 dfa86 = new DFA86(this);
	protected DFA91 dfa91 = new DFA91(this);
	protected DFA96 dfa96 = new DFA96(this);
	protected DFA102 dfa102 = new DFA102(this);
	protected DFA105 dfa105 = new DFA105(this);
	protected DFA110 dfa110 = new DFA110(this);
	protected DFA112 dfa112 = new DFA112(this);
	protected DFA114 dfa114 = new DFA114(this);
	protected DFA115 dfa115 = new DFA115(this);
	protected DFA123 dfa123 = new DFA123(this);
	protected DFA126 dfa126 = new DFA126(this);
	protected DFA127 dfa127 = new DFA127(this);
	protected DFA140 dfa140 = new DFA140(this);
	protected DFA158 dfa158 = new DFA158(this);
	protected DFA160 dfa160 = new DFA160(this);
	protected DFA162 dfa162 = new DFA162(this);
	protected DFA171 dfa171 = new DFA171(this);
	protected DFA179 dfa179 = new DFA179(this);
	protected DFA185 dfa185 = new DFA185(this);
	protected DFA187 dfa187 = new DFA187(this);
	protected DFA194 dfa194 = new DFA194(this);
	protected DFA199 dfa199 = new DFA199(this);
	protected DFA201 dfa201 = new DFA201(this);
	protected DFA212 dfa212 = new DFA212(this);
	protected DFA232 dfa232 = new DFA232(this);
	protected DFA233 dfa233 = new DFA233(this);
	protected DFA234 dfa234 = new DFA234(this);
	protected DFA239 dfa239 = new DFA239(this);
	protected DFA251 dfa251 = new DFA251(this);
	protected DFA278 dfa278 = new DFA278(this);
	protected DFA281 dfa281 = new DFA281(this);
	protected DFA289 dfa289 = new DFA289(this);
	protected DFA293 dfa293 = new DFA293(this);
	protected DFA296 dfa296 = new DFA296(this);
	protected DFA306 dfa306 = new DFA306(this);
	protected DFA308 dfa308 = new DFA308(this);
	protected DFA310 dfa310 = new DFA310(this);
	protected DFA309 dfa309 = new DFA309(this);
	protected DFA451 dfa451 = new DFA451(this);
	protected DFA468 dfa468 = new DFA468(this);
	static final String DFA1_eotS = "\116\uffff";
	static final String DFA1_eofS = "\116\uffff";
	static final String DFA1_minS = "\1\u00de\115\uffff";
	static final String DFA1_maxS = "\1\u012a\115\uffff";
	static final String DFA1_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"
				+ "\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31"
				+ "\1\32\1\33\1\34\1\35\1\36\1\37\1\40\1\41\1\42\1\43\1\44\1\45\1\46"
				+ "\1\47\1\50\1\51\1\52\1\53\1\54\1\55\1\56\1\57\1\60\1\61\1\62\1\63"
				+ "\1\64\1\65\1\66\1\67\1\70\1\71\1\72\1\73\1\74\1\75\1\76\1\77\1\100"
				+ "\1\101\1\102\1\103\1\104\1\105\1\106\1\107\1\110\1\111\1\112\1\113"
				+ "\1\114\1\115";
	static final String DFA1_specialS = "\116\uffff}>";
	static final String[] DFA1_transitionS =
		{
				"\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15"
						+ "\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31"
						+ "\1\32\1\33\1\34\1\35\1\36\1\37\1\40\1\41\1\42\1\43\1\44\1\45"
						+ "\1\46\1\47\1\50\1\51\1\52\1\53\1\54\1\55\1\56\1\57\1\60\1\61"
						+ "\1\62\1\63\1\64\1\65\1\66\1\67\1\70\1\71\1\72\1\73\1\74\1\75"
						+ "\1\76\1\77\1\100\1\101\1\102\1\103\1\104\1\105\1\106\1\107\1"
						+ "\110\1\111\1\112\1\113\1\114\1\115", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "" };

	static final short[] DFA1_eot = DFA.unpackEncodedString(DFA1_eotS);
	static final short[] DFA1_eof = DFA.unpackEncodedString(DFA1_eofS);
	static final char[] DFA1_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA1_minS);
	static final char[] DFA1_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA1_maxS);
	static final short[] DFA1_accept = DFA.unpackEncodedString(DFA1_acceptS);
	static final short[] DFA1_special = DFA.unpackEncodedString(DFA1_specialS);
	static final short[][] DFA1_transition;

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

	class DFA1 extends DFA {

		public DFA1(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 1;
			this.eot = DFA1_eot;
			this.eof = DFA1_eof;
			this.min = DFA1_min;
			this.max = DFA1_max;
			this.accept = DFA1_accept;
			this.special = DFA1_special;
			this.transition = DFA1_transition;
		}
		public String getDescription() {
			return "321:1: keyword : ( aBSTRACT | aS | bASE | bOOL | bREAK | bYTE | cASE | cATCH | cHAR | cHECKED | cLASS | cONST | cONTINUE | dECIMAL | dEFAULT | dELEGATE | dO | dOUBLE | eLSE | eNUM | eVENT | eXPLICIT | eXTERN | fALSE | fINALLY | fIXED | fLOAT | fOR | fOREACH | gOTO | iF | iMPLICIT | iN | iNT | iNTERFACE | iNTERNAL | iS | lOCK | lONG | nAMESPACE | nEW | nULL | oBJECT | oPERATOR | oUT | oVERRIDE | pARAMS | pRIVATE | pROTECTED | pUBLIC | rEADONLY | rEF | rETURN | sBYTE | sEALED | sHORT | sIZEOF | sTACKALLOC | sTATIC | sTRING | sTRUCT | sWITCH | tHIS | tHROW | tRUE | tRY | tYPEOF | uINT | uLONG | uNCHECKED | uNSAFE | uSHORT | uSING | vIRTUAL | vOID | vOLATILE | wHILE );";
		}
	}
	static final String DFA2_eotS = "\12\uffff";
	static final String DFA2_eofS = "\12\uffff";
	static final String DFA2_minS = "\1\u012b\11\uffff";
	static final String DFA2_maxS = "\1\u0133\11\uffff";
	static final String DFA2_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11";
	static final String DFA2_specialS = "\12\uffff}>";
	static final String[] DFA2_transitionS = {
			"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1", "", "", "", "", "", "",
			"", "", "" };

	static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
	static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
	static final char[] DFA2_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA2_minS);
	static final char[] DFA2_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA2_maxS);
	static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
	static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
	static final short[][] DFA2_transition;

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

	class DFA2 extends DFA {

		public DFA2(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 2;
			this.eot = DFA2_eot;
			this.eof = DFA2_eof;
			this.min = DFA2_min;
			this.max = DFA2_max;
			this.accept = DFA2_accept;
			this.special = DFA2_special;
			this.transition = DFA2_transition;
		}
		public String getDescription() {
			return "332:1: identifier returns [String content] : ( ident -> Identifier[$ident.start] | aDD -> Identifier[$aDD.start] | aLIAS -> Identifier[$aLIAS.start] | gET -> Identifier[$gET.start] | pARTIAL -> Identifier[$pARTIAL.start] | rEMOVE -> Identifier[$rEMOVE.start] | sET -> Identifier[$sET.start] | wHERE -> Identifier[$wHERE.start] | yIELD -> Identifier[$yIELD.start] );";
		}
	}
	static final String DFA6_eotS = "\23\uffff";
	static final String DFA6_eofS = "\1\2\22\uffff";
	static final String DFA6_minS = "\1\u00b4\1\0\21\uffff";
	static final String DFA6_maxS = "\1\u012e\1\0\21\uffff";
	static final String DFA6_acceptS = "\2\uffff\1\2\17\uffff\1\1";
	static final String DFA6_specialS = "\1\uffff\1\0\21\uffff}>";
	static final String[] DFA6_transitionS =
		{
				"\1\1\51\uffff\1\2\11\uffff\1\2\4\uffff\1\2\3\uffff\1\2\16\uffff"
						+ "\2\2\3\uffff\2\2\6\uffff\3\2\4\uffff\1\2\3\uffff\1\2\1\uffff"
						+ "\1\2\23\uffff\1\2", "\1\uffff", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA6_eot = DFA.unpackEncodedString(DFA6_eotS);
	static final short[] DFA6_eof = DFA.unpackEncodedString(DFA6_eofS);
	static final char[] DFA6_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA6_minS);
	static final char[] DFA6_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA6_maxS);
	static final short[] DFA6_accept = DFA.unpackEncodedString(DFA6_acceptS);
	static final short[] DFA6_special = DFA.unpackEncodedString(DFA6_specialS);
	static final short[][] DFA6_transition;

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

	class DFA6 extends DFA {

		public DFA6(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 6;
			this.eot = DFA6_eot;
			this.eof = DFA6_eof;
			this.min = DFA6_min;
			this.max = DFA6_max;
			this.accept = DFA6_accept;
			this.special = DFA6_special;
			this.transition = DFA6_transition;
		}
		public String getDescription() {
			return "366:62: ( globalattributes )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index6_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred88_CSharp())) {
						s = 18;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index6_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 6, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA10_eotS = "\14\uffff";
	static final String DFA10_eofS = "\14\uffff";
	static final String DFA10_minS = "\1\u012b\11\0\2\uffff";
	static final String DFA10_maxS = "\1\u0133\11\0\2\uffff";
	static final String DFA10_acceptS = "\12\uffff\1\1\1\2";
	static final String DFA10_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff}>";
	static final String[] DFA10_transitionS = {
			"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "", "" };

	static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
	static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
	static final char[] DFA10_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA10_minS);
	static final char[] DFA10_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA10_maxS);
	static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
	static final short[] DFA10_special = DFA
		.unpackEncodedString(DFA10_specialS);
	static final short[][] DFA10_transition;

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

	class DFA10 extends DFA {

		public DFA10(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 10;
			this.eot = DFA10_eot;
			this.eof = DFA10_eof;
			this.min = DFA10_min;
			this.max = DFA10_max;
			this.accept = DFA10_accept;
			this.special = DFA10_special;
			this.transition = DFA10_transition;
		}
		public String getDescription() {
			return "387:1: namespaceortypename returns [String name] : ( ( simplenamespaceortypename dOT )+ identifier ( typeargumentlist )? | simplenamespaceortypename );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index10_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index10_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index10_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index10_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index10_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index10_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index10_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index10_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index10_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index10_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index10_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index10_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index10_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred92_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index10_9);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 10, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA8_eotS = "\14\uffff";
	static final String DFA8_eofS = "\14\uffff";
	static final String DFA8_minS = "\1\u012b\11\0\2\uffff";
	static final String DFA8_maxS = "\1\u0133\11\0\2\uffff";
	static final String DFA8_acceptS = "\12\uffff\1\1\1\2";
	static final String DFA8_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff}>";
	static final String[] DFA8_transitionS = {
			"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "", "" };

	static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
	static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
	static final char[] DFA8_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA8_minS);
	static final char[] DFA8_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA8_maxS);
	static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
	static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
	static final short[][] DFA8_transition;

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

	class DFA8 extends DFA {

		public DFA8(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 8;
			this.eot = DFA8_eot;
			this.eof = DFA8_eof;
			this.min = DFA8_min;
			this.max = DFA8_max;
			this.accept = DFA8_accept;
			this.special = DFA8_special;
			this.transition = DFA8_transition;
		}
		public String getDescription() {
			return "()+ loopback of 391:4: ( simplenamespaceortypename dOT )+";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index8_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index8_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index8_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index8_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index8_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index8_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index8_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index8_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index8_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index8_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index8_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index8_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index8_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index8_9);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 8, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA9_eotS = "\46\uffff";
	static final String DFA9_eofS = "\1\2\45\uffff";
	static final String DFA9_minS = "\1\u00b2\1\0\44\uffff";
	static final String DFA9_maxS = "\1\u0133\1\0\44\uffff";
	static final String DFA9_acceptS = "\2\uffff\1\2\42\uffff\1\1";
	static final String DFA9_specialS = "\1\uffff\1\0\44\uffff}>";
	static final String[] DFA9_transitionS =
		{
				"\12\2\5\uffff\3\2\3\uffff\1\1\2\2\3\uffff\2\2\1\uffff\3\2\12"
						+ "\uffff\1\2\1\uffff\1\2\42\uffff\1\2\6\uffff\1\2\22\uffff\1\2"
						+ "\16\uffff\11\2", "\1\uffff", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA9_eot = DFA.unpackEncodedString(DFA9_eotS);
	static final short[] DFA9_eof = DFA.unpackEncodedString(DFA9_eofS);
	static final char[] DFA9_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA9_minS);
	static final char[] DFA9_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA9_maxS);
	static final short[] DFA9_accept = DFA.unpackEncodedString(DFA9_acceptS);
	static final short[] DFA9_special = DFA.unpackEncodedString(DFA9_specialS);
	static final short[][] DFA9_transition;

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

	class DFA9 extends DFA {

		public DFA9(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 9;
			this.eot = DFA9_eot;
			this.eof = DFA9_eof;
			this.min = DFA9_min;
			this.max = DFA9_max;
			this.accept = DFA9_accept;
			this.special = DFA9_special;
			this.transition = DFA9_transition;
		}
		public String getDescription() {
			return "392:14: ( typeargumentlist )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index9_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred91_CSharp())) {
						s = 37;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index9_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 9, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA12_eotS = "\25\uffff";
	static final String DFA12_eofS = "\1\uffff\12\14\2\uffff\10\14";
	static final String DFA12_minS = "\1\u012b\12\u00ad\2\uffff\10\u00ad";
	static final String DFA12_maxS = "\13\u0133\2\uffff\10\u0133";
	static final String DFA12_acceptS = "\13\uffff\1\2\1\1\10\uffff";
	static final String DFA12_specialS = "\25\uffff}>";
	static final String[] DFA12_transitionS =
		{
				"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1",
				"\5\12\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\15\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\16\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\17\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\20\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\21\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\22\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\23\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\24\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\12\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"",
				"",
				"\5\15\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\16\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\17\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\20\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\21\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\22\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\23\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14",
				"\5\24\12\14\5\uffff\3\14\3\uffff\3\14\1\13\2\uffff\2\14\1"
						+ "\uffff\3\14\12\uffff\1\14\1\uffff\1\14\42\uffff\1\14\6\uffff"
						+ "\1\14\22\uffff\1\14\16\uffff\11\14" };

	static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS);
	static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS);
	static final char[] DFA12_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA12_minS);
	static final char[] DFA12_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA12_maxS);
	static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS);
	static final short[] DFA12_special = DFA
		.unpackEncodedString(DFA12_specialS);
	static final short[][] DFA12_transition;

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

	class DFA12 extends DFA {

		public DFA12(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 12;
			this.eot = DFA12_eot;
			this.eof = DFA12_eof;
			this.min = DFA12_min;
			this.max = DFA12_max;
			this.accept = DFA12_accept;
			this.special = DFA12_special;
			this.transition = DFA12_transition;
		}
		public String getDescription() {
			return "397:1: simplenamespaceortypename returns [String name] : ( identifier ( typeargumentlist )? | qualifiedaliasmember );";
		}
	}
	static final String DFA11_eotS = "\46\uffff";
	static final String DFA11_eofS = "\1\2\45\uffff";
	static final String DFA11_minS = "\1\u00b2\1\0\44\uffff";
	static final String DFA11_maxS = "\1\u0133\1\0\44\uffff";
	static final String DFA11_acceptS = "\2\uffff\1\2\42\uffff\1\1";
	static final String DFA11_specialS = "\1\uffff\1\0\44\uffff}>";
	static final String[] DFA11_transitionS =
		{
				"\12\2\5\uffff\3\2\3\uffff\1\1\2\2\3\uffff\2\2\1\uffff\3\2\12"
						+ "\uffff\1\2\1\uffff\1\2\42\uffff\1\2\6\uffff\1\2\22\uffff\1\2"
						+ "\16\uffff\11\2", "\1\uffff", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS);
	static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS);
	static final char[] DFA11_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA11_minS);
	static final char[] DFA11_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA11_maxS);
	static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS);
	static final short[] DFA11_special = DFA
		.unpackEncodedString(DFA11_specialS);
	static final short[][] DFA11_transition;

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

	class DFA11 extends DFA {

		public DFA11(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 11;
			this.eot = DFA11_eot;
			this.eof = DFA11_eof;
			this.min = DFA11_min;
			this.max = DFA11_max;
			this.accept = DFA11_accept;
			this.special = DFA11_special;
			this.transition = DFA11_transition;
		}
		public String getDescription() {
			return "398:15: ( typeargumentlist )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index11_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred93_CSharp())) {
						s = 37;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index11_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 11, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA13_eotS = "\51\uffff";
	static final String DFA13_eofS = "\12\uffff\15\30\3\uffff\17\30";
	static final String DFA13_minS = "\1\u00e1\11\0\15\u00ad\3\uffff\17\u00ad";
	static final String DFA13_maxS =
		"\1\u0133\11\0\15\u0133\3\uffff\1\u0133\1\u0137\14\u0133\1\u0137";
	static final String DFA13_acceptS = "\27\uffff\1\1\1\2\1\3\17\uffff";
	static final String DFA13_specialS =
		"\1\uffff\1\0\1\2\1\1\1\6\1\10\1\7\1\3\1\5\1\4\37\uffff}>";
	static final String[] DFA13_transitionS =
		{
				"\1\26\1\uffff\1\13\2\uffff\1\22\4\uffff\1\25\3\uffff\1\24\10"
						+ "\uffff\1\23\6\uffff\1\16\4\uffff\1\20\3\uffff\1\27\12\uffff"
						+ "\1\12\1\uffff\1\14\3\uffff\1\27\7\uffff\1\17\1\21\2\uffff\1"
						+ "\15\5\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1",
				"\1\uffff",
				"\1\uffff",
				"\1\uffff",
				"\1\uffff",
				"\1\uffff",
				"\1\uffff",
				"\1\uffff",
				"\1\uffff",
				"\1\uffff",
				"\5\32\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\34\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\35\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\36\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\37\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\40\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\41\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\42\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\43\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\44\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\45\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\46\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\47\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"",
				"",
				"",
				"\5\32\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\50\1\uffff\1\30\1\27\3\30\1\uffff\5\30\3\uffff\5\30\1\uffff"
						+ "\3\30\1\uffff\4\30\1\uffff\3\30\12\uffff\1\30\1\uffff\3\30\1"
						+ "\uffff\1\30\2\uffff\2\30\3\uffff\3\30\1\uffff\1\30\5\uffff\1"
						+ "\30\2\uffff\1\30\6\uffff\1\30\2\uffff\1\30\1\uffff\1\30\1\uffff"
						+ "\4\30\11\uffff\1\30\1\uffff\1\30\3\uffff\1\30\2\uffff\1\30\1"
						+ "\uffff\1\30\1\uffff\4\30\1\uffff\1\30\5\uffff\15\30",
				"\5\34\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\35\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\36\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\37\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\40\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\41\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\42\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\43\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\44\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\45\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\46\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\47\1\uffff\1\30\1\27\3\30\1\uffff\3\30\5\uffff\3\30\3\uffff"
						+ "\1\30\1\33\1\30\3\uffff\2\30\1\uffff\3\30\12\uffff\1\30\1\uffff"
						+ "\1\30\42\uffff\1\30\6\uffff\1\30\22\uffff\1\30\16\uffff\11\30",
				"\5\50\1\uffff\1\30\1\27\3\30\1\uffff\5\30\3\uffff\5\30\1\uffff"
						+ "\3\30\1\uffff\4\30\1\uffff\3\30\12\uffff\1\30\1\uffff\3\30\1"
						+ "\uffff\1\30\2\uffff\2\30\3\uffff\3\30\1\uffff\1\30\5\uffff\1"
						+ "\30\2\uffff\1\30\6\uffff\1\30\2\uffff\1\30\1\uffff\1\30\1\uffff"
						+ "\4\30\11\uffff\1\30\1\uffff\1\30\3\uffff\1\30\2\uffff\1\30\1"
						+ "\uffff\1\30\1\uffff\4\30\1\uffff\1\30\5\uffff\15\30" };

	static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
	static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
	static final char[] DFA13_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA13_minS);
	static final char[] DFA13_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA13_maxS);
	static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
	static final short[] DFA13_special = DFA
		.unpackEncodedString(DFA13_specialS);
	static final short[][] DFA13_transition;

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

	class DFA13 extends DFA {

		public DFA13(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 13;
			this.eot = DFA13_eot;
			this.eof = DFA13_eof;
			this.min = DFA13_min;
			this.max = DFA13_max;
			this.accept = DFA13_accept;
			this.special = DFA13_special;
			this.transition = DFA13_transition;
		}
		public String getDescription() {
			return "406:1: type returns [String name] : ( referencetype -> ^( Type referencetype ) | valuetype -> ^( Type valuetype ) | typeparameter -> ^( Type typeparameter ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index13_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index13_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index13_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index13_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index13_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index13_9);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index13_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index13_8);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index13_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index13_4);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index13_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index13_6);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index13_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred95_CSharp())) {
						s = 23;
					}

					else if ((synpred96_CSharp())) {
						s = 24;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index13_5);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 13, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA14_eotS = "\14\uffff";
	static final String DFA14_eofS = "\14\uffff";
	static final String DFA14_minS = "\1\u00e1\11\0\2\uffff";
	static final String DFA14_maxS = "\1\u0133\11\0\2\uffff";
	static final String DFA14_acceptS = "\12\uffff\1\1\1\2";
	static final String DFA14_specialS =
		"\1\uffff\1\5\1\4\1\10\1\3\1\7\1\2\1\6\1\1\1\0\2\uffff}>";
	static final String[] DFA14_transitionS =
		{
				"\1\12\1\uffff\1\12\2\uffff\1\12\4\uffff\1\12\3\uffff\1\12\10"
						+ "\uffff\1\12\6\uffff\1\12\4\uffff\1\12\16\uffff\1\12\1\uffff"
						+ "\1\12\13\uffff\2\12\2\uffff\1\12\5\uffff\1\2\1\3\1\4\1\5\1\6"
						+ "\1\7\1\10\1\11\1\1", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "", "" };

	static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS);
	static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS);
	static final char[] DFA14_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA14_minS);
	static final char[] DFA14_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA14_maxS);
	static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS);
	static final short[] DFA14_special = DFA
		.unpackEncodedString(DFA14_specialS);
	static final short[][] DFA14_transition;

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

	class DFA14 extends DFA {

		public DFA14(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 14;
			this.eot = DFA14_eot;
			this.eof = DFA14_eof;
			this.min = DFA14_min;
			this.max = DFA14_max;
			this.accept = DFA14_accept;
			this.special = DFA14_special;
			this.transition = DFA14_transition;
		}
		public String getDescription() {
			return "418:1: valuetype returns [String name] : ( structtype | enumtype );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index14_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index14_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index14_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index14_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index14_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index14_2);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index14_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index14_1);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index14_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index14_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index14_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index14_5);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index14_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred97_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index14_3);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 14, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA15_eotS = "\32\uffff";
	static final String DFA15_eofS = "\32\uffff";
	static final String DFA15_minS = "\1\u00e1\26\0\3\uffff";
	static final String DFA15_maxS = "\1\u0133\26\0\3\uffff";
	static final String DFA15_acceptS = "\27\uffff\1\1\1\2\1\3";
	static final String DFA15_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\3\uffff}>";
	static final String[] DFA15_transitionS =
		{
				"\1\26\1\uffff\1\13\2\uffff\1\22\4\uffff\1\25\3\uffff\1\24\10"
						+ "\uffff\1\23\6\uffff\1\16\4\uffff\1\20\16\uffff\1\12\1\uffff"
						+ "\1\14\13\uffff\1\17\1\21\2\uffff\1\15\5\uffff\1\2\1\3\1\4\1"
						+ "\5\1\6\1\7\1\10\1\11\1\1", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "",
				"", "" };

	static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS);
	static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS);
	static final char[] DFA15_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA15_minS);
	static final char[] DFA15_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA15_maxS);
	static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS);
	static final short[] DFA15_special = DFA
		.unpackEncodedString(DFA15_specialS);
	static final short[][] DFA15_transition;

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

	class DFA15 extends DFA {

		public DFA15(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 15;
			this.eot = DFA15_eot;
			this.eof = DFA15_eof;
			this.min = DFA15_min;
			this.max = DFA15_max;
			this.accept = DFA15_accept;
			this.special = DFA15_special;
			this.transition = DFA15_transition;
		}
		public String getDescription() {
			return "425:1: structtype returns [String name] : ( nullabletype | typename | simpletype );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index15_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

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

					int index15_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

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

					int index15_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

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

					int index15_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

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

					int index15_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

					input.seek(index15_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index15_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

					input.seek(index15_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index15_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

					input.seek(index15_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index15_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

					input.seek(index15_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index15_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((synpred99_CSharp())) {
						s = 24;
					}

					input.seek(index15_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index15_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index15_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index15_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index15_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index15_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index15_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index15_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index15_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index15_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index15_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index15_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index15_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index15_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred98_CSharp())) {
						s = 23;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index15_22);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 15, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA18_eotS = "\12\uffff";
	static final String DFA18_eofS = "\12\uffff";
	static final String DFA18_minS = "\1\u00e3\11\uffff";
	static final String DFA18_maxS = "\1\u0125\11\uffff";
	static final String DFA18_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11";
	static final String DFA18_specialS = "\12\uffff}>";
	static final String[] DFA18_transitionS = {
			"\1\2\2\uffff\1\11\30\uffff\1\5\4\uffff\1\7\16\uffff\1\1\1\uffff"
					+ "\1\3\13\uffff\1\6\1\10\2\uffff\1\4", "", "", "", "", "",
			"", "", "", "" };

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

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

	class DFA18 extends DFA {

		public DFA18(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 18;
			this.eot = DFA18_eot;
			this.eof = DFA18_eof;
			this.min = DFA18_min;
			this.max = DFA18_max;
			this.accept = DFA18_accept;
			this.special = DFA18_special;
			this.transition = DFA18_transition;
		}
		public String getDescription() {
			return "449:1: integralType : ( sBYTE | bYTE | sHORT | uSHORT | iNT | uINT | lONG | uLONG | cHAR );";
		}
	}
	static final String DFA20_eotS = "\15\uffff";
	static final String DFA20_eofS = "\15\uffff";
	static final String DFA20_minS = "\1\u00e1\11\0\3\uffff";
	static final String DFA20_maxS = "\1\u0133\11\0\3\uffff";
	static final String DFA20_acceptS = "\12\uffff\1\3\1\1\1\2";
	static final String DFA20_specialS =
		"\1\uffff\1\6\1\2\1\7\1\5\1\0\1\10\1\1\1\3\1\4\3\uffff}>";
	static final String[] DFA20_transitionS =
		{
				"\1\12\1\uffff\1\12\2\uffff\1\12\4\uffff\1\12\3\uffff\1\12\10"
						+ "\uffff\1\12\6\uffff\1\12\4\uffff\1\12\16\uffff\1\12\1\uffff"
						+ "\1\12\13\uffff\2\12\2\uffff\1\12\5\uffff\1\2\1\3\1\4\1\5\1\6"
						+ "\1\7\1\10\1\11\1\1", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "", "", "" };

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

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

	class DFA20 extends DFA {

		public DFA20(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 20;
			this.eot = DFA20_eot;
			this.eof = DFA20_eof;
			this.min = DFA20_min;
			this.max = DFA20_max;
			this.accept = DFA20_accept;
			this.special = DFA20_special;
			this.transition = DFA20_transition;
		}
		public String getDescription() {
			return "477:1: nonnullablevaluetype returns [String name] : ( enumtype | typename | simpletype );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index20_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

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

					int index20_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

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

					int index20_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

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

					int index20_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

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

					int index20_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

					input.seek(index20_9);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index20_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

					input.seek(index20_4);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index20_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

					input.seek(index20_1);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index20_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

					input.seek(index20_3);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index20_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred112_CSharp())) {
						s = 11;
					}

					else if ((synpred113_CSharp())) {
						s = 12;
					}

					input.seek(index20_6);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 20, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA21_eotS = "\22\uffff";
	static final String DFA21_eofS = "\13\uffff\2\15\3\uffff\2\15";
	static final String DFA21_minS =
		"\1\u00e1\11\u00ad\1\uffff\2\u00ad\3\uffff\2\u00ad";
	static final String DFA21_maxS =
		"\1\u0133\11\u00ca\1\uffff\2\u0133\3\uffff\2\u0133";
	static final String DFA21_acceptS =
		"\12\uffff\1\1\2\uffff\1\2\1\3\1\4\2\uffff";
	static final String DFA21_specialS =
		"\1\uffff\1\2\1\3\1\4\1\5\1\0\1\6\1\10\1\1\1\7\10\uffff}>";
	static final String[] DFA21_transitionS =
		{
				"\1\12\1\uffff\1\12\2\uffff\1\12\4\uffff\1\12\3\uffff\1\12\10"
						+ "\uffff\1\12\6\uffff\1\12\4\uffff\1\12\3\uffff\1\13\12\uffff"
						+ "\1\12\1\uffff\1\12\3\uffff\1\14\7\uffff\2\12\2\uffff\1\12\5"
						+ "\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"\5\12\2\uffff\1\12\3\uffff\1\12\16\uffff\2\12\1\uffff\1\12",
				"",
				"\5\20\1\uffff\1\15\1\12\3\15\1\uffff\3\15\5\uffff\3\15\3\uffff"
						+ "\3\15\3\uffff\2\15\1\uffff\3\15\12\uffff\1\15\1\uffff\1\15\42"
						+ "\uffff\1\15\6\uffff\1\15\22\uffff\1\15\16\uffff\11\15",
				"\5\21\1\uffff\1\15\1\12\3\15\1\uffff\3\15\5\uffff\3\15\3\uffff"
						+ "\3\15\3\uffff\2\15\1\uffff\3\15\12\uffff\1\15\1\uffff\1\15\42"
						+ "\uffff\1\15\6\uffff\1\15\22\uffff\1\15\16\uffff\11\15",
				"",
				"",
				"",
				"\5\20\1\uffff\1\15\1\12\3\15\1\uffff\3\15\5\uffff\3\15\3\uffff"
						+ "\3\15\3\uffff\2\15\1\uffff\3\15\12\uffff\1\15\1\uffff\1\15\42"
						+ "\uffff\1\15\6\uffff\1\15\22\uffff\1\15\16\uffff\11\15",
				"\5\21\1\uffff\1\15\1\12\3\15\1\uffff\3\15\5\uffff\3\15\3\uffff"
						+ "\3\15\3\uffff\2\15\1\uffff\3\15\12\uffff\1\15\1\uffff\1\15\42"
						+ "\uffff\1\15\6\uffff\1\15\22\uffff\1\15\16\uffff\11\15" };

	static final short[] DFA21_eot = DFA.unpackEncodedString(DFA21_eotS);
	static final short[] DFA21_eof = DFA.unpackEncodedString(DFA21_eofS);
	static final char[] DFA21_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA21_minS);
	static final char[] DFA21_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA21_maxS);
	static final short[] DFA21_accept = DFA.unpackEncodedString(DFA21_acceptS);
	static final short[] DFA21_special = DFA
		.unpackEncodedString(DFA21_specialS);
	static final short[][] DFA21_transition;

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

	class DFA21 extends DFA {

		public DFA21(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 21;
			this.eot = DFA21_eot;
			this.eof = DFA21_eof;
			this.min = DFA21_min;
			this.max = DFA21_max;
			this.accept = DFA21_accept;
			this.special = DFA21_special;
			this.transition = DFA21_transition;
		}
		public String getDescription() {
			return "486:1: referencetype returns [String name] : ( arraytype | classtype | interfacetype | delegatetype );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					int LA21_5 = input.LA(1);

					int index21_5 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_5 >= Whitespace && LA21_5 <= Preprocessordirective)
							|| LA21_5 == LBRACKET
							|| LA21_5 == DOT
							|| (LA21_5 >= LT && LA21_5 <= QUESTION) || LA21_5 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

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

					int index21_8 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_8 >= Whitespace && LA21_8 <= Preprocessordirective)
							|| LA21_8 == LBRACKET
							|| LA21_8 == DOT
							|| (LA21_8 >= LT && LA21_8 <= QUESTION) || LA21_8 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

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

					int index21_1 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_1 >= Whitespace && LA21_1 <= Preprocessordirective)
							|| LA21_1 == LBRACKET
							|| LA21_1 == DOT
							|| (LA21_1 >= LT && LA21_1 <= QUESTION) || LA21_1 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

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

					int index21_2 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_2 >= Whitespace && LA21_2 <= Preprocessordirective)
							|| LA21_2 == LBRACKET
							|| LA21_2 == DOT
							|| (LA21_2 >= LT && LA21_2 <= QUESTION) || LA21_2 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

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

					int index21_3 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_3 >= Whitespace && LA21_3 <= Preprocessordirective)
							|| LA21_3 == LBRACKET
							|| LA21_3 == DOT
							|| (LA21_3 >= LT && LA21_3 <= QUESTION) || LA21_3 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index21_3);
					if (s >= 0)
						return s;
					break;
				case 5 :
					int LA21_4 = input.LA(1);

					int index21_4 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_4 >= Whitespace && LA21_4 <= Preprocessordirective)
							|| LA21_4 == LBRACKET
							|| LA21_4 == DOT
							|| (LA21_4 >= LT && LA21_4 <= QUESTION) || LA21_4 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index21_4);
					if (s >= 0)
						return s;
					break;
				case 6 :
					int LA21_6 = input.LA(1);

					int index21_6 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_6 >= Whitespace && LA21_6 <= Preprocessordirective)
							|| LA21_6 == LBRACKET
							|| LA21_6 == DOT
							|| (LA21_6 >= LT && LA21_6 <= QUESTION) || LA21_6 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index21_6);
					if (s >= 0)
						return s;
					break;
				case 7 :
					int LA21_9 = input.LA(1);

					int index21_9 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_9 >= Whitespace && LA21_9 <= Preprocessordirective)
							|| LA21_9 == LBRACKET
							|| LA21_9 == DOT
							|| (LA21_9 >= LT && LA21_9 <= QUESTION) || LA21_9 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index21_9);
					if (s >= 0)
						return s;
					break;
				case 8 :
					int LA21_7 = input.LA(1);

					int index21_7 = input.index();
					input.rewind();
					s = -1;
					if (((LA21_7 >= Whitespace && LA21_7 <= Preprocessordirective)
							|| LA21_7 == LBRACKET
							|| LA21_7 == DOT
							|| (LA21_7 >= LT && LA21_7 <= QUESTION) || LA21_7 == DOUBLECOLON)) {
						s = 10;
					}

					else if ((synpred115_CSharp())) {
						s = 13;
					}

					else if ((synpred116_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index21_7);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 21, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA25_eotS = "\52\uffff";
	static final String DFA25_eofS = "\52\uffff";
	static final String DFA25_minS = "\1\u00b6\1\0\50\uffff";
	static final String DFA25_maxS = "\1\u0137\1\0\50\uffff";
	static final String DFA25_acceptS = "\2\uffff\1\1\46\uffff\1\2";
	static final String DFA25_specialS = "\1\uffff\1\0\50\uffff}>";
	static final String[] DFA25_transitionS =
		{
				"\1\2\51\uffff\2\2\1\uffff\1\2\2\uffff\2\2\3\uffff\3\2\1\uffff"
						+ "\1\2\5\uffff\1\2\2\uffff\1\2\6\uffff\1\2\4\uffff\1\2\1\uffff"
						+ "\1\1\2\2\12\uffff\1\2\1\uffff\1\2\3\uffff\1\2\2\uffff\1\2\1"
						+ "\uffff\1\2\1\uffff\4\2\1\uffff\1\2\5\uffff\15\2",
				"\1\uffff", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA25_eot = DFA.unpackEncodedString(DFA25_eotS);
	static final short[] DFA25_eof = DFA.unpackEncodedString(DFA25_eofS);
	static final char[] DFA25_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA25_minS);
	static final char[] DFA25_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA25_maxS);
	static final short[] DFA25_accept = DFA.unpackEncodedString(DFA25_acceptS);
	static final short[] DFA25_special = DFA
		.unpackEncodedString(DFA25_specialS);
	static final short[][] DFA25_transition;

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

	class DFA25 extends DFA {

		public DFA25(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 25;
			this.eot = DFA25_eot;
			this.eof = DFA25_eof;
			this.min = DFA25_min;
			this.max = DFA25_max;
			this.accept = DFA25_accept;
			this.special = DFA25_special;
			this.transition = DFA25_transition;
		}
		public String getDescription() {
			return "547:1: primaryexpression options {memoize=true; } : ( primarynoarraycreationexpression | arraycreationexpression_withoutinitializer );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index25_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred122_CSharp())) {
						s = 2;
					}

					else if ((true)) {
						s = 41;
					}

					input.seek(index25_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 25, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA26_eotS = "\52\uffff";
	static final String DFA26_eofS = "\52\uffff";
	static final String DFA26_minS = "\1\u00b6\1\0\50\uffff";
	static final String DFA26_maxS = "\1\u0137\1\0\50\uffff";
	static final String DFA26_acceptS = "\2\uffff\1\2\46\uffff\1\1";
	static final String DFA26_specialS = "\1\uffff\1\0\50\uffff}>";
	static final String[] DFA26_transitionS =
		{
				"\1\2\51\uffff\2\2\1\uffff\1\2\2\uffff\2\2\3\uffff\3\2\1\uffff"
						+ "\1\2\5\uffff\1\2\2\uffff\1\2\6\uffff\1\2\4\uffff\1\2\1\uffff"
						+ "\1\1\2\2\12\uffff\1\2\1\uffff\1\2\3\uffff\1\2\2\uffff\1\2\1"
						+ "\uffff\1\2\1\uffff\4\2\1\uffff\1\2\5\uffff\15\2",
				"\1\uffff", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA26_eot = DFA.unpackEncodedString(DFA26_eotS);
	static final short[] DFA26_eof = DFA.unpackEncodedString(DFA26_eofS);
	static final char[] DFA26_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA26_minS);
	static final char[] DFA26_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA26_maxS);
	static final short[] DFA26_accept = DFA.unpackEncodedString(DFA26_acceptS);
	static final short[] DFA26_special = DFA
		.unpackEncodedString(DFA26_specialS);
	static final short[][] DFA26_transition;

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

	class DFA26 extends DFA {

		public DFA26(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 26;
			this.eot = DFA26_eot;
			this.eof = DFA26_eof;
			this.min = DFA26_min;
			this.max = DFA26_max;
			this.accept = DFA26_accept;
			this.special = DFA26_special;
			this.transition = DFA26_transition;
		}
		public String getDescription() {
			return "567:1: primary_nonrec : ( arraycreationexpression_withoutinitializer | primarynoarray_nonrec );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index26_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred123_CSharp())) {
						s = 41;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index26_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 26, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA27_eotS = "\57\uffff";
	static final String DFA27_eofS = "\57\uffff";
	static final String DFA27_minS = "\1\u00b6\50\0\6\uffff";
	static final String DFA27_maxS = "\1\u0137\50\0\6\uffff";
	static final String DFA27_acceptS = "\51\uffff\1\1\1\2\1\3\1\4\1\5\1\6";
	static final String DFA27_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30"
				+ "\1\31\1\32\1\33\1\34\1\35\1\36\1\37\1\40\1\41\1\42\1\43\1\44\1\45"
				+ "\1\46\1\47\6\uffff}>";
	static final String[] DFA27_transitionS =
		{
				"\1\22\51\uffff\1\43\1\23\1\uffff\1\24\2\uffff\1\25\1\45\3\uffff"
						+ "\1\26\1\47\1\50\1\uffff\1\27\5\uffff\1\3\2\uffff\1\30\6\uffff"
						+ "\1\31\4\uffff\1\32\1\uffff\1\1\1\10\1\33\12\uffff\1\34\1\uffff"
						+ "\1\35\3\uffff\1\36\2\uffff\1\42\1\uffff\1\2\1\uffff\1\44\1\37"
						+ "\1\40\1\46\1\uffff\1\41\5\uffff\1\12\1\13\1\14\1\15\1\16\1\17"
						+ "\1\20\1\21\1\11\1\4\1\5\1\6\1\7", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "", "", "", "",
				"", "" };

	static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS);
	static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS);
	static final char[] DFA27_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA27_minS);
	static final char[] DFA27_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA27_maxS);
	static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS);
	static final short[] DFA27_special = DFA
		.unpackEncodedString(DFA27_specialS);
	static final short[][] DFA27_transition;

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

	class DFA27 extends DFA {

		public DFA27(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 27;
			this.eot = DFA27_eot;
			this.eof = DFA27_eof;
			this.min = DFA27_min;
			this.max = DFA27_max;
			this.accept = DFA27_accept;
			this.special = DFA27_special;
			this.transition = DFA27_transition;
		}
		public String getDescription() {
			return "572:1: primarynoarraycreationexpression : ( memberaccess_rec_rest | invocationexpression | elementaccess | postincrementexpression | postdecrementexpression | primarynoarray_nonrec );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index27_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

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

					int index27_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

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

					int index27_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

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

					int index27_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

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

					int index27_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index27_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index27_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index27_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index27_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index27_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index27_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index27_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index27_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index27_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index27_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index27_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index27_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index27_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index27_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index27_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index27_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index27_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index27_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index27_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_24);
					if (s >= 0)
						return s;
					break;
				case 24 :
					input.LA(1);

					int index27_25 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_25);
					if (s >= 0)
						return s;
					break;
				case 25 :
					input.LA(1);

					int index27_26 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_26);
					if (s >= 0)
						return s;
					break;
				case 26 :
					input.LA(1);

					int index27_27 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_27);
					if (s >= 0)
						return s;
					break;
				case 27 :
					input.LA(1);

					int index27_28 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_28);
					if (s >= 0)
						return s;
					break;
				case 28 :
					input.LA(1);

					int index27_29 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_29);
					if (s >= 0)
						return s;
					break;
				case 29 :
					input.LA(1);

					int index27_30 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_30);
					if (s >= 0)
						return s;
					break;
				case 30 :
					input.LA(1);

					int index27_31 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_31);
					if (s >= 0)
						return s;
					break;
				case 31 :
					input.LA(1);

					int index27_32 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_32);
					if (s >= 0)
						return s;
					break;
				case 32 :
					input.LA(1);

					int index27_33 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_33);
					if (s >= 0)
						return s;
					break;
				case 33 :
					input.LA(1);

					int index27_34 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_34);
					if (s >= 0)
						return s;
					break;
				case 34 :
					input.LA(1);

					int index27_35 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_35);
					if (s >= 0)
						return s;
					break;
				case 35 :
					input.LA(1);

					int index27_36 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_36);
					if (s >= 0)
						return s;
					break;
				case 36 :
					input.LA(1);

					int index27_37 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_37);
					if (s >= 0)
						return s;
					break;
				case 37 :
					input.LA(1);

					int index27_38 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_38);
					if (s >= 0)
						return s;
					break;
				case 38 :
					input.LA(1);

					int index27_39 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_39);
					if (s >= 0)
						return s;
					break;
				case 39 :
					input.LA(1);

					int index27_40 = input.index();
					input.rewind();
					s = -1;
					if ((synpred124_CSharp())) {
						s = 41;
					}

					else if ((synpred125_CSharp())) {
						s = 42;
					}

					else if ((synpred126_CSharp())) {
						s = 43;
					}

					else if ((synpred127_CSharp())) {
						s = 44;
					}

					else if ((synpred128_CSharp())) {
						s = 45;
					}

					else if ((true)) {
						s = 46;
					}

					input.seek(index27_40);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 27, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA28_eotS = "\54\uffff";
	static final String DFA28_eofS = "\54\uffff";
	static final String DFA28_minS = "\1\u00b6\1\0\7\uffff\11\0\32\uffff";
	static final String DFA28_maxS = "\1\u0137\1\0\7\uffff\11\0\32\uffff";
	static final String DFA28_acceptS =
		"\2\uffff\1\2\17\uffff\1\4\1\5\16\uffff\1\6\1\7\1\11\1\12\1\13\1"
				+ "\14\1\15\1\1\1\10\1\3";
	static final String DFA28_specialS =
		"\1\uffff\1\0\7\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\32\uffff}>";
	static final String[] DFA28_transitionS =
		{
				"\1\22\51\uffff\1\43\1\23\1\uffff\1\23\2\uffff\1\23\1\45\3\uffff"
						+ "\1\23\1\47\1\50\1\uffff\1\23\5\uffff\1\2\2\uffff\1\23\6\uffff"
						+ "\1\23\4\uffff\1\23\1\uffff\1\1\1\2\1\23\12\uffff\1\23\1\uffff"
						+ "\1\23\3\uffff\1\23\2\uffff\1\42\1\uffff\1\2\1\uffff\1\44\2\23"
						+ "\1\46\1\uffff\1\23\5\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\20"
						+ "\1\21\1\11\4\2", "\1\uffff", "", "", "", "", "", "",
				"", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "" };

	static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS);
	static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS);
	static final char[] DFA28_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA28_minS);
	static final char[] DFA28_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA28_maxS);
	static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS);
	static final short[] DFA28_special = DFA
		.unpackEncodedString(DFA28_specialS);
	static final short[][] DFA28_transition;

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

	class DFA28 extends DFA {

		public DFA28(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 28;
			this.eot = DFA28_eot;
			this.eof = DFA28_eof;
			this.min = DFA28_min;
			this.max = DFA28_max;
			this.accept = DFA28_accept;
			this.special = DFA28_special;
			this.transition = DFA28_transition;
		}
		public String getDescription() {
			return "582:1: primarynoarray_nonrec : ( arraycreationexpression_withinitializer | literal | simplename | parenthesizedexpression | memberaccess_nonrec | thisaccess | baseaccess | objectcreationexpression | typeofexpression | checkedexpression | uncheckedexpression | defaultvalueexpression | anonymousmethodexpression );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index28_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred129_CSharp())) {
						s = 41;
					}

					else if ((synpred136_CSharp())) {
						s = 42;
					}

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

					int index28_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

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

					int index28_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

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

					int index28_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

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

					int index28_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

					input.seek(index28_12);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index28_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

					input.seek(index28_13);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index28_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

					input.seek(index28_14);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index28_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

					input.seek(index28_15);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index28_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

					input.seek(index28_16);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index28_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred131_CSharp())) {
						s = 43;
					}

					else if ((synpred133_CSharp())) {
						s = 19;
					}

					input.seek(index28_17);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 28, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA29_eotS = "\54\uffff";
	static final String DFA29_eofS = "\1\2\53\uffff";
	static final String DFA29_minS = "\1\u00b3\1\0\52\uffff";
	static final String DFA29_maxS = "\1\u0102\1\0\52\uffff";
	static final String DFA29_acceptS = "\2\uffff\1\2\50\uffff\1\1";
	static final String DFA29_specialS = "\1\uffff\1\0\52\uffff}>";
	static final String[] DFA29_transitionS = {
			"\21\2\2\uffff\1\2\1\1\2\2\1\uffff\4\2\1\uffff\16\2\1\uffff"
					+ "\1\2\42\uffff\1\2", "\1\uffff", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "" };

	static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
	static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
	static final char[] DFA29_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA29_minS);
	static final char[] DFA29_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA29_maxS);
	static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
	static final short[] DFA29_special = DFA
		.unpackEncodedString(DFA29_specialS);
	static final short[][] DFA29_transition;

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

	class DFA29 extends DFA {

		public DFA29(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 29;
			this.eot = DFA29_eot;
			this.eof = DFA29_eof;
			this.min = DFA29_min;
			this.max = DFA29_max;
			this.accept = DFA29_accept;
			this.special = DFA29_special;
			this.transition = DFA29_transition;
		}
		public String getDescription() {
			return "607:34: ( typeargumentlist )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index29_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred141_CSharp())) {
						s = 43;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index29_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 29, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA30_eotS = "\54\uffff";
	static final String DFA30_eofS = "\1\2\53\uffff";
	static final String DFA30_minS = "\1\u00b3\1\0\52\uffff";
	static final String DFA30_maxS = "\1\u0102\1\0\52\uffff";
	static final String DFA30_acceptS = "\2\uffff\1\2\50\uffff\1\1";
	static final String DFA30_specialS = "\1\uffff\1\0\52\uffff}>";
	static final String[] DFA30_transitionS = {
			"\21\2\2\uffff\1\2\1\1\2\2\1\uffff\4\2\1\uffff\16\2\1\uffff"
					+ "\1\2\42\uffff\1\2", "\1\uffff", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "" };

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

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

	class DFA30 extends DFA {

		public DFA30(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 30;
			this.eot = DFA30_eot;
			this.eof = DFA30_eof;
			this.min = DFA30_min;
			this.max = DFA30_max;
			this.accept = DFA30_accept;
			this.special = DFA30_special;
			this.transition = DFA30_transition;
		}
		public String getDescription() {
			return "609:40: ( typeargumentlist )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index30_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred143_CSharp())) {
						s = 43;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index30_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 30, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA34_eotS = "\54\uffff";
	static final String DFA34_eofS = "\1\2\53\uffff";
	static final String DFA34_minS = "\1\u00b3\1\0\52\uffff";
	static final String DFA34_maxS = "\1\u0102\1\0\52\uffff";
	static final String DFA34_acceptS = "\2\uffff\1\2\50\uffff\1\1";
	static final String DFA34_specialS = "\1\uffff\1\0\52\uffff}>";
	static final String[] DFA34_transitionS = {
			"\21\2\2\uffff\1\2\1\1\2\2\1\uffff\4\2\1\uffff\16\2\1\uffff"
					+ "\1\2\42\uffff\1\2", "\1\uffff", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "" };

	static final short[] DFA34_eot = DFA.unpackEncodedString(DFA34_eotS);
	static final short[] DFA34_eof = DFA.unpackEncodedString(DFA34_eofS);
	static final char[] DFA34_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA34_minS);
	static final char[] DFA34_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA34_maxS);
	static final short[] DFA34_accept = DFA.unpackEncodedString(DFA34_acceptS);
	static final short[] DFA34_special = DFA
		.unpackEncodedString(DFA34_specialS);
	static final short[][] DFA34_transition;

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

	class DFA34 extends DFA {

		public DFA34(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 34;
			this.eot = DFA34_eot;
			this.eof = DFA34_eof;
			this.min = DFA34_min;
			this.max = DFA34_max;
			this.accept = DFA34_accept;
			this.special = DFA34_special;
			this.transition = DFA34_transition;
		}
		public String getDescription() {
			return "629:19: ( typeargumentlist )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index34_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred149_CSharp())) {
						s = 43;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index34_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 34, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA44_eotS = "\54\uffff";
	static final String DFA44_eofS = "\1\2\53\uffff";
	static final String DFA44_minS = "\1\u00b3\1\0\52\uffff";
	static final String DFA44_maxS = "\1\u0102\1\0\52\uffff";
	static final String DFA44_acceptS = "\2\uffff\1\2\50\uffff\1\1";
	static final String DFA44_specialS = "\1\uffff\1\0\52\uffff}>";
	static final String[] DFA44_transitionS = {
			"\21\2\2\uffff\1\2\1\1\2\2\1\uffff\4\2\1\uffff\16\2\1\uffff"
					+ "\1\2\42\uffff\1\2", "\1\uffff", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "" };

	static final short[] DFA44_eot = DFA.unpackEncodedString(DFA44_eotS);
	static final short[] DFA44_eof = DFA.unpackEncodedString(DFA44_eofS);
	static final char[] DFA44_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA44_minS);
	static final char[] DFA44_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA44_maxS);
	static final short[] DFA44_accept = DFA.unpackEncodedString(DFA44_acceptS);
	static final short[] DFA44_special = DFA
		.unpackEncodedString(DFA44_specialS);
	static final short[][] DFA44_transition;

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

	class DFA44 extends DFA {

		public DFA44(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 44;
			this.eot = DFA44_eot;
			this.eof = DFA44_eof;
			this.min = DFA44_min;
			this.max = DFA44_max;
			this.accept = DFA44_accept;
			this.special = DFA44_special;
			this.transition = DFA44_transition;
		}
		public String getDescription() {
			return "723:20: ( typeargumentlist )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index44_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred171_CSharp())) {
						s = 43;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index44_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 44, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA45_eotS = "\20\uffff";
	static final String DFA45_eofS = "\20\uffff";
	static final String DFA45_minS = "\1\u00e1\17\uffff";
	static final String DFA45_maxS = "\1\u0125\17\uffff";
	static final String DFA45_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"
				+ "\15\1\16\1\17";
	static final String DFA45_specialS = "\20\uffff}>";
	static final String[] DFA45_transitionS =
		{
				"\1\1\1\uffff\1\2\2\uffff\1\3\4\uffff\1\4\3\uffff\1\5\10\uffff"
						+ "\1\6\6\uffff\1\7\4\uffff\1\10\3\uffff\1\11\12\uffff\1\12\1\uffff"
						+ "\1\13\3\uffff\1\14\7\uffff\1\15\1\16\2\uffff\1\17",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA45_eot = DFA.unpackEncodedString(DFA45_eotS);
	static final short[] DFA45_eof = DFA.unpackEncodedString(DFA45_eofS);
	static final char[] DFA45_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA45_minS);
	static final char[] DFA45_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA45_maxS);
	static final short[] DFA45_accept = DFA.unpackEncodedString(DFA45_acceptS);
	static final short[] DFA45_special = DFA
		.unpackEncodedString(DFA45_specialS);
	static final short[][] DFA45_transition;

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

	class DFA45 extends DFA {

		public DFA45(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 45;
			this.eot = DFA45_eot;
			this.eof = DFA45_eof;
			this.min = DFA45_min;
			this.max = DFA45_max;
			this.accept = DFA45_accept;
			this.special = DFA45_special;
			this.transition = DFA45_transition;
		}
		public String getDescription() {
			return "734:1: predefinedtype : ( bOOL | bYTE | cHAR | dECIMAL | dOUBLE | fLOAT | iNT | lONG | oBJECT | sBYTE | sHORT | sTRING | uINT | uLONG | uSHORT );";
		}
	}
	static final String DFA48_eotS = "\5\uffff";
	static final String DFA48_eofS = "\5\uffff";
	static final String DFA48_minS = "\1\u00e0\2\u00ad\2\uffff";
	static final String DFA48_maxS = "\1\u00e0\2\u00b8\2\uffff";
	static final String DFA48_acceptS = "\3\uffff\1\2\1\1";
	static final String DFA48_specialS = "\5\uffff}>";
	static final String[] DFA48_transitionS = { "\1\1",
			"\5\2\2\uffff\1\3\3\uffff\1\4", "\5\2\2\uffff\1\3\3\uffff\1\4", "",
			"" };

	static final short[] DFA48_eot = DFA.unpackEncodedString(DFA48_eotS);
	static final short[] DFA48_eof = DFA.unpackEncodedString(DFA48_eofS);
	static final char[] DFA48_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA48_minS);
	static final char[] DFA48_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA48_maxS);
	static final short[] DFA48_accept = DFA.unpackEncodedString(DFA48_acceptS);
	static final short[] DFA48_special = DFA
		.unpackEncodedString(DFA48_specialS);
	static final short[][] DFA48_transition;

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

	class DFA48 extends DFA {

		public DFA48(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 48;
			this.eot = DFA48_eot;
			this.eof = DFA48_eof;
			this.min = DFA48_min;
			this.max = DFA48_max;
			this.accept = DFA48_accept;
			this.special = DFA48_special;
			this.transition = DFA48_transition;
		}
		public String getDescription() {
			return "751:1: baseaccess : ( bASE dOT identifier ( typeargumentlist )? -> ^( BaseAccess bASE dOT identifier ( typeargumentlist )? ) | bASE lBRACKET expressionlist rBRACKET -> ^( BaseAccess bASE lBRACKET expressionlist rBRACKET ) );";
		}
	}
	static final String DFA47_eotS = "\54\uffff";
	static final String DFA47_eofS = "\1\2\53\uffff";
	static final String DFA47_minS = "\1\u00b3\1\0\52\uffff";
	static final String DFA47_maxS = "\1\u0102\1\0\52\uffff";
	static final String DFA47_acceptS = "\2\uffff\1\2\50\uffff\1\1";
	static final String DFA47_specialS = "\1\uffff\1\0\52\uffff}>";
	static final String[] DFA47_transitionS = {
			"\21\2\2\uffff\1\2\1\1\2\2\1\uffff\4\2\1\uffff\16\2\1\uffff"
					+ "\1\2\42\uffff\1\2", "\1\uffff", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
			"", "" };

	static final short[] DFA47_eot = DFA.unpackEncodedString(DFA47_eotS);
	static final short[] DFA47_eof = DFA.unpackEncodedString(DFA47_eofS);
	static final char[] DFA47_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA47_minS);
	static final char[] DFA47_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA47_maxS);
	static final short[] DFA47_accept = DFA.unpackEncodedString(DFA47_acceptS);
	static final short[] DFA47_special = DFA
		.unpackEncodedString(DFA47_specialS);
	static final short[][] DFA47_transition;

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

	class DFA47 extends DFA {

		public DFA47(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 47;
			this.eot = DFA47_eot;
			this.eof = DFA47_eof;
			this.min = DFA47_min;
			this.max = DFA47_max;
			this.accept = DFA47_accept;
			this.special = DFA47_special;
			this.transition = DFA47_transition;
		}
		public String getDescription() {
			return "752:29: ( typeargumentlist )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index47_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred187_CSharp())) {
						s = 43;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index47_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 47, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA53_eotS = "\5\uffff";
	static final String DFA53_eofS = "\1\2\4\uffff";
	static final String DFA53_minS = "\1\u00b3\1\u00ad\1\uffff\1\u00ad\1\uffff";
	static final String DFA53_maxS = "\1\u0102\1\u0137\1\uffff\1\u0137\1\uffff";
	static final String DFA53_acceptS = "\2\uffff\1\2\1\uffff\1\1";
	static final String DFA53_specialS = "\5\uffff}>";
	static final String[] DFA53_transitionS =
		{
				"\1\2\1\1\17\2\2\uffff\4\2\1\uffff\4\2\1\uffff\16\2\1\uffff"
						+ "\1\2\42\uffff\1\2",
				"\5\3\3\uffff\1\4\1\2\2\uffff\1\4\2\uffff\2\2\6\uffff\2\2\5"
						+ "\uffff\2\2\23\uffff\2\2\1\uffff\1\2\2\uffff\2\2\3\uffff\3\2"
						+ "\1\uffff\1\2\5\uffff\1\2\2\uffff\1\2\6\uffff\1\2\4\uffff\1\2"
						+ "\1\uffff\3\2\12\uffff\1\2\1\uffff\1\2\3\uffff\1\2\2\uffff\1"
						+ "\2\1\uffff\1\2\1\uffff\4\2\1\uffff\1\2\5\uffff\15\2",
				"",
				"\5\3\3\uffff\1\4\1\2\2\uffff\1\4\2\uffff\2\2\6\uffff\2\2\5"
						+ "\uffff\2\2\23\uffff\2\2\1\uffff\1\2\2\uffff\2\2\3\uffff\3\2"
						+ "\1\uffff\1\2\5\uffff\1\2\2\uffff\1\2\6\uffff\1\2\4\uffff\1\2"
						+ "\1\uffff\3\2\12\uffff\1\2\1\uffff\1\2\3\uffff\1\2\2\uffff\1"
						+ "\2\1\uffff\1\2\1\uffff\4\2\1\uffff\1\2\5\uffff\15\2",
				"" };

	static final short[] DFA53_eot = DFA.unpackEncodedString(DFA53_eotS);
	static final short[] DFA53_eof = DFA.unpackEncodedString(DFA53_eofS);
	static final char[] DFA53_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA53_minS);
	static final char[] DFA53_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA53_maxS);
	static final short[] DFA53_accept = DFA.unpackEncodedString(DFA53_acceptS);
	static final short[] DFA53_special = DFA
		.unpackEncodedString(DFA53_specialS);
	static final short[][] DFA53_transition;

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

	class DFA53 extends DFA {

		public DFA53(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 53;
			this.eot = DFA53_eot;
			this.eof = DFA53_eof;
			this.min = DFA53_min;
			this.max = DFA53_max;
			this.accept = DFA53_accept;
			this.special = DFA53_special;
			this.transition = DFA53_transition;
		}
		public String getDescription() {
			return "786:57: ( rankspecifiers )?";
		}
	}
	static final String DFA54_eotS = "\137\uffff";
	static final String DFA54_eofS = "\137\uffff";
	static final String DFA54_minS =
		"\1\u0120\15\u00ad\2\uffff\4\u00ad\1\0\11\u00ad\1\uffff\100\u00ad";
	static final String DFA54_maxS =
		"\1\u0120\2\u00b6\2\u0133\11\u00ca\2\uffff\1\u00ca\3\u0133\1\0\10"
				+ "\u00ca\1\u0133\1\uffff\1\u0133\11\u00ca\1\u0133\11\u00c8\1\u00ca"
				+ "\1\u0133\10\u00ca\1\u00c8\2\u0133\10\u00c8\3\u0133\12\u00ca\1\u0133"
				+ "\10\u00ca\1\u0133";
	static final String DFA54_acceptS =
		"\16\uffff\1\1\1\3\16\uffff\1\2\100\uffff";
	static final String DFA54_specialS = "\24\uffff\1\0\112\uffff}>";
	static final String[] DFA54_transitionS =
		{
				"\1\1",
				"\5\2\4\uffff\1\3",
				"\5\2\4\uffff\1\3",
				"\5\4\57\uffff\1\16\1\uffff\1\16\2\uffff\1\16\4\uffff\1\16"
						+ "\3\uffff\1\16\10\uffff\1\16\6\uffff\1\16\4\uffff\1\16\3\uffff"
						+ "\1\16\12\uffff\1\16\1\uffff\1\16\3\uffff\1\16\7\uffff\2\16\2"
						+ "\uffff\1\16\2\uffff\1\17\2\uffff\1\6\1\7\1\10\1\11\1\12\1\13"
						+ "\1\14\1\15\1\5",
				"\5\4\57\uffff\1\16\1\uffff\1\16\2\uffff\1\16\4\uffff\1\16"
						+ "\3\uffff\1\16\10\uffff\1\16\6\uffff\1\16\4\uffff\1\16\3\uffff"
						+ "\1\16\12\uffff\1\16\1\uffff\1\16\3\uffff\1\16\7\uffff\2\16\2"
						+ "\uffff\1\16\2\uffff\1\17\2\uffff\1\6\1\7\1\10\1\11\1\12\1\13"
						+ "\1\14\1\15\1\5",
				"\5\20\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\25\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\26\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\27\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\30\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\31\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\32\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\33\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\34\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"",
				"",
				"\5\20\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\35\7\uffff\1\36\43\uffff\1\36\3\uffff\1\16\1\uffff\1\16"
						+ "\2\uffff\1\16\4\uffff\1\16\3\uffff\1\16\10\uffff\1\16\6\uffff"
						+ "\1\16\4\uffff\1\16\3\uffff\1\16\12\uffff\1\16\1\uffff\1\16\3"
						+ "\uffff\1\16\7\uffff\2\16\2\uffff\1\16\5\uffff\11\16",
				"\5\37\171\uffff\1\41\1\42\1\43\1\44\1\45\1\46\1\47\1\50\1"
						+ "\40",
				"\5\51\171\uffff\1\53\1\54\1\55\1\56\1\57\1\60\1\61\1\62\1"
						+ "\52",
				"\1\uffff",
				"\5\25\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\26\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\27\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\30\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\31\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\32\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\33\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\34\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\21\1\16\1"
						+ "\uffff\1\23",
				"\5\35\7\uffff\1\36\43\uffff\1\36\3\uffff\1\16\1\uffff\1\16"
						+ "\2\uffff\1\16\4\uffff\1\16\3\uffff\1\16\10\uffff\1\16\6\uffff"
						+ "\1\16\4\uffff\1\16\3\uffff\1\16\12\uffff\1\16\1\uffff\1\16\3"
						+ "\uffff\1\16\7\uffff\2\16\2\uffff\1\16\5\uffff\11\16",
				"",
				"\5\37\171\uffff\1\41\1\42\1\43\1\44\1\45\1\46\1\47\1\50\1"
						+ "\40",
				"\5\63\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\65\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\66\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\67\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\70\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\71\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\72\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\73\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\74\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\51\171\uffff\1\53\1\54\1\55\1\56\1\57\1\60\1\61\1\62\1"
						+ "\52",
				"\5\75\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\100\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\101\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\102\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\103\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\104\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\105\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\106\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\107\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\63\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\110\7\uffff\1\36\43\uffff\1\36\3\uffff\1\16\1\uffff\1\16"
						+ "\2\uffff\1\16\4\uffff\1\16\3\uffff\1\16\10\uffff\1\16\6\uffff"
						+ "\1\16\4\uffff\1\16\3\uffff\1\16\12\uffff\1\16\1\uffff\1\16\3"
						+ "\uffff\1\16\7\uffff\2\16\2\uffff\1\16\5\uffff\11\16",
				"\5\65\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\66\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\67\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\70\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\71\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\72\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\73\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\74\2\uffff\1\16\2\uffff\1\24\1\22\16\uffff\1\64\1\16\1"
						+ "\uffff\1\16",
				"\5\75\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\111\7\uffff\1\36\43\uffff\1\36\3\uffff\1\16\1\uffff\1\16"
						+ "\2\uffff\1\16\4\uffff\1\16\3\uffff\1\16\10\uffff\1\16\6\uffff"
						+ "\1\16\4\uffff\1\16\3\uffff\1\16\12\uffff\1\16\1\uffff\1\16\3"
						+ "\uffff\1\16\7\uffff\2\16\2\uffff\1\16\5\uffff\11\16",
				"\5\112\171\uffff\1\114\1\115\1\116\1\117\1\120\1\121\1\122"
						+ "\1\123\1\113",
				"\5\100\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\101\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\102\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\103\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\104\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\105\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\106\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\107\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\76\1\16",
				"\5\110\7\uffff\1\36\43\uffff\1\36\3\uffff\1\16\1\uffff\1\16"
						+ "\2\uffff\1\16\4\uffff\1\16\3\uffff\1\16\10\uffff\1\16\6\uffff"
						+ "\1\16\4\uffff\1\16\3\uffff\1\16\12\uffff\1\16\1\uffff\1\16\3"
						+ "\uffff\1\16\7\uffff\2\16\2\uffff\1\16\5\uffff\11\16",
				"\5\111\7\uffff\1\36\43\uffff\1\36\3\uffff\1\16\1\uffff\1\16"
						+ "\2\uffff\1\16\4\uffff\1\16\3\uffff\1\16\10\uffff\1\16\6\uffff"
						+ "\1\16\4\uffff\1\16\3\uffff\1\16\12\uffff\1\16\1\uffff\1\16\3"
						+ "\uffff\1\16\7\uffff\2\16\2\uffff\1\16\5\uffff\11\16",
				"\5\112\171\uffff\1\114\1\115\1\116\1\117\1\120\1\121\1\122"
						+ "\1\123\1\113",
				"\5\124\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\126\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\127\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\130\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\131\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\132\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\133\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\134\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\135\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\124\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\136\7\uffff\1\36\43\uffff\1\36\3\uffff\1\16\1\uffff\1\16"
						+ "\2\uffff\1\16\4\uffff\1\16\3\uffff\1\16\10\uffff\1\16\6\uffff"
						+ "\1\16\4\uffff\1\16\3\uffff\1\16\12\uffff\1\16\1\uffff\1\16\3"
						+ "\uffff\1\16\7\uffff\2\16\2\uffff\1\16\5\uffff\11\16",
				"\5\126\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\127\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\130\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\131\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\132\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\133\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\134\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\135\2\uffff\1\16\2\uffff\1\24\1\77\16\uffff\1\125\1\16"
						+ "\1\uffff\1\16",
				"\5\136\7\uffff\1\36\43\uffff\1\36\3\uffff\1\16\1\uffff\1\16"
						+ "\2\uffff\1\16\4\uffff\1\16\3\uffff\1\16\10\uffff\1\16\6\uffff"
						+ "\1\16\4\uffff\1\16\3\uffff\1\16\12\uffff\1\16\1\uffff\1\16\3"
						+ "\uffff\1\16\7\uffff\2\16\2\uffff\1\16\5\uffff\11\16" };

	static final short[] DFA54_eot = DFA.unpackEncodedString(DFA54_eotS);
	static final short[] DFA54_eof = DFA.unpackEncodedString(DFA54_eofS);
	static final char[] DFA54_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA54_minS);
	static final char[] DFA54_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA54_maxS);
	static final short[] DFA54_accept = DFA.unpackEncodedString(DFA54_acceptS);
	static final short[] DFA54_special = DFA
		.unpackEncodedString(DFA54_specialS);
	static final short[][] DFA54_transition;

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

	class DFA54 extends DFA {

		public DFA54(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 54;
			this.eot = DFA54_eot;
			this.eof = DFA54_eof;
			this.min = DFA54_min;
			this.max = DFA54_max;
			this.accept = DFA54_accept;
			this.special = DFA54_special;
			this.transition = DFA54_transition;
		}
		public String getDescription() {
			return "790:1: typeofexpression : ( tYPEOF lPAREN type rPAREN -> ^( TypeOfExpression tYPEOF lPAREN type rPAREN ) | tYPEOF lPAREN unboundtypename rPAREN -> ^( TypeOfExpression tYPEOF lPAREN unboundtypename rPAREN ) | tYPEOF lPAREN vOID rPAREN -> ^( TypeOfExpression tYPEOF lPAREN vOID rPAREN ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index54_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred194_CSharp())) {
						s = 14;
					}

					else if ((synpred195_CSharp())) {
						s = 30;
					}

					input.seek(index54_20);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 54, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA61_eotS = "\25\uffff";
	static final String DFA61_eofS = "\25\uffff";
	static final String DFA61_minS = "\1\u012b\12\u00ad\2\uffff\10\u00ad";
	static final String DFA61_maxS = "\1\u0133\12\u00ca\2\uffff\10\u00ca";
	static final String DFA61_acceptS = "\13\uffff\1\1\1\2\10\uffff";
	static final String DFA61_specialS = "\25\uffff}>";
	static final String[] DFA61_transitionS = {
			"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1",
			"\5\12\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\15\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\16\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\17\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\20\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\21\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\22\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\23\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\24\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\12\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14", "", "",
			"\5\15\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\16\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\17\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\20\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\21\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\22\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\23\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14",
			"\5\24\5\uffff\2\13\16\uffff\1\13\2\uffff\1\14" };

	static final short[] DFA61_eot = DFA.unpackEncodedString(DFA61_eotS);
	static final short[] DFA61_eof = DFA.unpackEncodedString(DFA61_eofS);
	static final char[] DFA61_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA61_minS);
	static final char[] DFA61_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA61_maxS);
	static final short[] DFA61_accept = DFA.unpackEncodedString(DFA61_acceptS);
	static final short[] DFA61_special = DFA
		.unpackEncodedString(DFA61_specialS);
	static final short[][] DFA61_transition;

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

	class DFA61 extends DFA {

		public DFA61(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 61;
			this.eot = DFA61_eot;
			this.eof = DFA61_eof;
			this.min = DFA61_min;
			this.max = DFA61_max;
			this.accept = DFA61_accept;
			this.special = DFA61_special;
			this.transition = DFA61_transition;
		}
		public String getDescription() {
			return "807:1: unboundtypename : ( identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* -> ^( UnboundTypeName identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* ) | identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* -> ^( UnboundTypeName identifier dOUBLECOLON identifier ( genericdimensionspecifier )? ( dOT identifier ( genericdimensionspecifier )? )* ) );";
		}
	}
	static final String DFA68_eotS = "\60\uffff";
	static final String DFA68_eofS = "\60\uffff";
	static final String DFA68_minS = "\1\u00b6\1\0\56\uffff";
	static final String DFA68_maxS = "\1\u0137\1\0\56\uffff";
	static final String DFA68_acceptS =
		"\2\uffff\1\2\46\uffff\1\3\1\4\1\5\1\6\1\7\1\10\1\1";
	static final String DFA68_specialS = "\1\uffff\1\0\56\uffff}>";
	static final String[] DFA68_transitionS =
		{
				"\1\1\5\uffff\1\51\1\52\6\uffff\1\53\1\54\5\uffff\1\55\1\56"
						+ "\23\uffff\2\2\1\uffff\1\2\2\uffff\2\2\3\uffff\3\2\1\uffff\1"
						+ "\2\5\uffff\1\2\2\uffff\1\2\6\uffff\1\2\4\uffff\1\2\1\uffff\3"
						+ "\2\12\uffff\1\2\1\uffff\1\2\3\uffff\1\2\2\uffff\1\2\1\uffff"
						+ "\1\2\1\uffff\4\2\1\uffff\1\2\5\uffff\15\2",
				"\1\uffff", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"" };

	static final short[] DFA68_eot = DFA.unpackEncodedString(DFA68_eotS);
	static final short[] DFA68_eof = DFA.unpackEncodedString(DFA68_eofS);
	static final char[] DFA68_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA68_minS);
	static final char[] DFA68_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA68_maxS);
	static final short[] DFA68_accept = DFA.unpackEncodedString(DFA68_acceptS);
	static final short[] DFA68_special = DFA
		.unpackEncodedString(DFA68_specialS);
	static final short[][] DFA68_transition;

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

	class DFA68 extends DFA {

		public DFA68(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 68;
			this.eot = DFA68_eot;
			this.eof = DFA68_eof;
			this.min = DFA68_min;
			this.max = DFA68_max;
			this.accept = DFA68_accept;
			this.special = DFA68_special;
			this.transition = DFA68_transition;
		}
		public String getDescription() {
			return "855:1: unaryexpression options {memoize=true; } : ( castexpression | primaryexpression | pLUS unaryexpression | mINUS unaryexpression | eXCLAM unaryexpression | tILDE unaryexpression | preincrementexpression | predecrementexpression );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index68_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred209_CSharp())) {
						s = 47;
					}

					else if ((synpred210_CSharp())) {
						s = 2;
					}

					input.seek(index68_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 68, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA82_eotS = "\61\uffff";
	static final String DFA82_eofS = "\61\uffff";
	static final String DFA82_minS = "\1\u00b6\56\0\2\uffff";
	static final String DFA82_maxS = "\1\u0137\56\0\2\uffff";
	static final String DFA82_acceptS = "\57\uffff\1\1\1\2";
	static final String DFA82_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30"
				+ "\1\31\1\32\1\33\1\34\1\35\1\36\1\37\1\40\1\41\1\42\1\43\1\44\1\45"
				+ "\1\46\1\47\1\50\1\51\1\52\1\53\1\54\1\55\2\uffff}>";
	static final String[] DFA82_transitionS =
		{
				"\1\1\5\uffff\1\51\1\52\6\uffff\1\53\1\54\5\uffff\1\55\1\56"
						+ "\23\uffff\1\43\1\23\1\uffff\1\24\2\uffff\1\25\1\45\3\uffff\1"
						+ "\26\1\47\1\50\1\uffff\1\27\5\uffff\1\4\2\uffff\1\30\6\uffff"
						+ "\1\31\4\uffff\1\32\1\uffff\1\2\1\11\1\33\12\uffff\1\34\1\uffff"
						+ "\1\35\3\uffff\1\36\2\uffff\1\42\1\uffff\1\3\1\uffff\1\44\1\37"
						+ "\1\40\1\46\1\uffff\1\41\5\uffff\1\13\1\14\1\15\1\16\1\17\1\20"
						+ "\1\21\1\22\1\12\1\5\1\6\1\7\1\10", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "",
				"" };

	static final short[] DFA82_eot = DFA.unpackEncodedString(DFA82_eotS);
	static final short[] DFA82_eof = DFA.unpackEncodedString(DFA82_eofS);
	static final char[] DFA82_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA82_minS);
	static final char[] DFA82_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA82_maxS);
	static final short[] DFA82_accept = DFA.unpackEncodedString(DFA82_acceptS);
	static final short[] DFA82_special = DFA
		.unpackEncodedString(DFA82_specialS);
	static final short[][] DFA82_transition;

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

	class DFA82 extends DFA {

		public DFA82(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 82;
			this.eot = DFA82_eot;
			this.eof = DFA82_eof;
			this.min = DFA82_min;
			this.max = DFA82_max;
			this.accept = DFA82_accept;
			this.special = DFA82_special;
			this.transition = DFA82_transition;
		}
		public String getDescription() {
			return "984:1: expression options {memoize=true; } : ( assignment | conditionalexpression );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index82_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

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

					int index82_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

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

					int index82_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

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

					int index82_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

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

					int index82_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index82_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index82_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index82_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index82_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index82_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index82_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index82_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index82_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index82_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index82_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index82_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index82_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index82_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index82_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index82_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index82_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index82_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index82_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index82_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_24);
					if (s >= 0)
						return s;
					break;
				case 24 :
					input.LA(1);

					int index82_25 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_25);
					if (s >= 0)
						return s;
					break;
				case 25 :
					input.LA(1);

					int index82_26 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_26);
					if (s >= 0)
						return s;
					break;
				case 26 :
					input.LA(1);

					int index82_27 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_27);
					if (s >= 0)
						return s;
					break;
				case 27 :
					input.LA(1);

					int index82_28 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_28);
					if (s >= 0)
						return s;
					break;
				case 28 :
					input.LA(1);

					int index82_29 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_29);
					if (s >= 0)
						return s;
					break;
				case 29 :
					input.LA(1);

					int index82_30 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_30);
					if (s >= 0)
						return s;
					break;
				case 30 :
					input.LA(1);

					int index82_31 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_31);
					if (s >= 0)
						return s;
					break;
				case 31 :
					input.LA(1);

					int index82_32 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_32);
					if (s >= 0)
						return s;
					break;
				case 32 :
					input.LA(1);

					int index82_33 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_33);
					if (s >= 0)
						return s;
					break;
				case 33 :
					input.LA(1);

					int index82_34 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_34);
					if (s >= 0)
						return s;
					break;
				case 34 :
					input.LA(1);

					int index82_35 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_35);
					if (s >= 0)
						return s;
					break;
				case 35 :
					input.LA(1);

					int index82_36 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_36);
					if (s >= 0)
						return s;
					break;
				case 36 :
					input.LA(1);

					int index82_37 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_37);
					if (s >= 0)
						return s;
					break;
				case 37 :
					input.LA(1);

					int index82_38 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_38);
					if (s >= 0)
						return s;
					break;
				case 38 :
					input.LA(1);

					int index82_39 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_39);
					if (s >= 0)
						return s;
					break;
				case 39 :
					input.LA(1);

					int index82_40 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_40);
					if (s >= 0)
						return s;
					break;
				case 40 :
					input.LA(1);

					int index82_41 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_41);
					if (s >= 0)
						return s;
					break;
				case 41 :
					input.LA(1);

					int index82_42 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_42);
					if (s >= 0)
						return s;
					break;
				case 42 :
					input.LA(1);

					int index82_43 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_43);
					if (s >= 0)
						return s;
					break;
				case 43 :
					input.LA(1);

					int index82_44 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_44);
					if (s >= 0)
						return s;
					break;
				case 44 :
					input.LA(1);

					int index82_45 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_45);
					if (s >= 0)
						return s;
					break;
				case 45 :
					input.LA(1);

					int index82_46 = input.index();
					input.rewind();
					s = -1;
					if ((synpred248_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 48;
					}

					input.seek(index82_46);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 82, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA83_eotS = "\101\uffff";
	static final String DFA83_eofS = "\101\uffff";
	static final String DFA83_minS = "\1\u00b2\30\0\50\uffff";
	static final String DFA83_maxS = "\1\u0137\30\0\50\uffff";
	static final String DFA83_acceptS = "\31\uffff\1\2\1\3\45\uffff\1\1";
	static final String DFA83_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\50\uffff}>";
	static final String[] DFA83_transitionS =
		{
				"\1\32\3\uffff\1\32\4\uffff\3\32\6\uffff\2\32\5\uffff\2\32\23"
						+ "\uffff\1\32\1\26\1\32\1\13\2\uffff\1\22\1\32\1\uffff\1\31\1"
						+ "\32\1\25\3\32\1\24\5\uffff\1\32\2\uffff\1\23\4\32\2\uffff\1"
						+ "\16\3\uffff\1\32\1\20\1\uffff\2\32\1\27\11\uffff\1\32\1\12\1"
						+ "\uffff\1\14\3\uffff\1\30\1\uffff\6\32\1\17\1\21\1\32\1\uffff"
						+ "\1\15\1\32\3\uffff\1\32\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1"
						+ "\1\4\32", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA83_eot = DFA.unpackEncodedString(DFA83_eotS);
	static final short[] DFA83_eof = DFA.unpackEncodedString(DFA83_eofS);
	static final char[] DFA83_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA83_minS);
	static final char[] DFA83_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA83_maxS);
	static final short[] DFA83_accept = DFA.unpackEncodedString(DFA83_acceptS);
	static final short[] DFA83_special = DFA
		.unpackEncodedString(DFA83_specialS);
	static final short[][] DFA83_transition;

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

	class DFA83 extends DFA {

		public DFA83(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 83;
			this.eot = DFA83_eot;
			this.eof = DFA83_eof;
			this.min = DFA83_min;
			this.max = DFA83_max;
			this.accept = DFA83_accept;
			this.special = DFA83_special;
			this.transition = DFA83_transition;
		}
		public String getDescription() {
			return "1005:1: statement : ( labeledstatement -> ^( Statement labeledstatement ) | declarationstatement -> ^( Statement declarationstatement ) | embeddedstatement -> ^( Statement embeddedstatement ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index83_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

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

					int index83_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

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

					int index83_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

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

					int index83_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

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

					int index83_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index83_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index83_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index83_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index83_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred249_CSharp())) {
						s = 64;
					}

					else if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index83_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index83_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index83_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index83_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index83_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index83_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index83_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index83_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index83_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index83_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index83_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index83_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index83_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index83_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index83_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred250_CSharp())) {
						s = 25;
					}

					else if ((true)) {
						s = 26;
					}

					input.seek(index83_24);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 83, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA84_eotS = "\23\uffff";
	static final String DFA84_eofS = "\23\uffff";
	static final String DFA84_minS =
		"\1\u00b2\3\uffff\3\u00ad\6\uffff\1\u00ad\1\uffff\1\u00ad\1\uffff"
				+ "\1\u00ad\1\uffff";
	static final String DFA84_maxS =
		"\1\u0137\3\uffff\1\u0112\2\u00b6\6\uffff\1\u0112\1\uffff\1\u00b6"
				+ "\1\uffff\1\u00b6\1\uffff";
	static final String DFA84_acceptS =
		"\1\uffff\1\1\1\2\1\3\3\uffff\1\4\1\5\1\6\1\7\1\12\1\13\1\uffff"
				+ "\1\14\1\uffff\1\10\1\uffff\1\11";
	static final String DFA84_specialS = "\23\uffff}>";
	static final String[] DFA84_transitionS =
		{
				"\1\1\3\uffff\1\3\4\uffff\1\2\2\3\6\uffff\2\3\5\uffff\2\3\23"
						+ "\uffff\2\3\1\11\1\3\2\uffff\1\3\1\5\2\uffff\1\11\3\3\1\10\1"
						+ "\3\5\uffff\1\3\2\uffff\1\3\2\10\1\11\1\7\2\uffff\1\3\3\uffff"
						+ "\1\13\1\3\1\uffff\3\3\11\uffff\1\11\1\3\1\uffff\1\3\3\uffff"
						+ "\1\3\1\uffff\1\7\1\3\1\11\1\3\1\12\3\3\1\6\1\uffff\1\3\1\14"
						+ "\3\uffff\1\10\7\3\1\4\5\3",
				"",
				"",
				"",
				"\5\15\2\uffff\1\3\1\uffff\1\3\1\uffff\1\3\15\uffff\2\3\2\uffff"
						+ "\3\3\6\uffff\10\3\1\uffff\2\3\4\uffff\1\16\57\uffff\1\16",
				"\5\17\1\20\3\uffff\1\3",
				"\5\21\1\22\3\uffff\1\3",
				"",
				"",
				"",
				"",
				"",
				"",
				"\5\15\2\uffff\1\3\1\uffff\1\3\1\uffff\1\3\15\uffff\2\3\2\uffff"
						+ "\3\3\6\uffff\10\3\1\uffff\2\3\4\uffff\1\16\57\uffff\1\16",
				"", "\5\17\1\20\3\uffff\1\3", "", "\5\21\1\22\3\uffff\1\3", "" };

	static final short[] DFA84_eot = DFA.unpackEncodedString(DFA84_eotS);
	static final short[] DFA84_eof = DFA.unpackEncodedString(DFA84_eofS);
	static final char[] DFA84_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA84_minS);
	static final char[] DFA84_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA84_maxS);
	static final short[] DFA84_accept = DFA.unpackEncodedString(DFA84_acceptS);
	static final short[] DFA84_special = DFA
		.unpackEncodedString(DFA84_specialS);
	static final short[][] DFA84_transition;

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

	class DFA84 extends DFA {

		public DFA84(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 84;
			this.eot = DFA84_eot;
			this.eof = DFA84_eof;
			this.min = DFA84_min;
			this.max = DFA84_max;
			this.accept = DFA84_accept;
			this.special = DFA84_special;
			this.transition = DFA84_transition;
		}
		public String getDescription() {
			return "1014:1: embeddedstatement : ( block | emptystatement | expressionstatement | selectionstatement | iterationstatement | jumpstatement | trystatement | checkedstatement | uncheckedstatement | lockstatement | usingstatement | yieldstatement );";
		}
	}
	static final String DFA86_eotS = "\5\uffff";
	static final String DFA86_eofS = "\1\1\4\uffff";
	static final String DFA86_minS = "\1\u00b2\1\uffff\1\u00ad\1\uffff\1\u00ad";
	static final String DFA86_maxS = "\1\u0137\1\uffff\1\u00ba\1\uffff\1\u00ba";
	static final String DFA86_acceptS = "\1\uffff\1\2\1\uffff\1\1\1\uffff";
	static final String DFA86_specialS = "\5\uffff}>";
	static final String[] DFA86_transitionS =
		{
				"\1\3\1\1\2\uffff\1\3\4\uffff\3\3\6\uffff\2\3\5\uffff\2\3\23"
						+ "\uffff\4\3\1\1\1\uffff\2\3\1\uffff\3\3\1\2\3\3\5\uffff\1\3\2"
						+ "\uffff\5\3\2\uffff\1\3\3\uffff\2\3\1\uffff\3\3\11\uffff\2\3"
						+ "\1\uffff\1\3\3\uffff\1\3\1\uffff\11\3\1\uffff\2\3\3\uffff\16"
						+ "\3", "", "\5\4\4\uffff\1\3\3\uffff\1\1", "",
				"\5\4\4\uffff\1\3\3\uffff\1\1" };

	static final short[] DFA86_eot = DFA.unpackEncodedString(DFA86_eotS);
	static final short[] DFA86_eof = DFA.unpackEncodedString(DFA86_eofS);
	static final char[] DFA86_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA86_minS);
	static final char[] DFA86_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA86_maxS);
	static final short[] DFA86_accept = DFA.unpackEncodedString(DFA86_acceptS);
	static final short[] DFA86_special = DFA
		.unpackEncodedString(DFA86_specialS);
	static final short[][] DFA86_transition;

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

	class DFA86 extends DFA {

		public DFA86(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 86;
			this.eot = DFA86_eot;
			this.eof = DFA86_eof;
			this.min = DFA86_min;
			this.max = DFA86_max;
			this.accept = DFA86_accept;
			this.special = DFA86_special;
			this.transition = DFA86_transition;
		}
		public String getDescription() {
			return "()+ loopback of 1035:9: ( statement )+";
		}
	}
	static final String DFA91_eotS = "\65\uffff";
	static final String DFA91_eofS = "\65\uffff";
	static final String DFA91_minS = "\1\u00b6\50\0\4\uffff\2\0\6\uffff";
	static final String DFA91_maxS = "\1\u0137\50\0\4\uffff\2\0\6\uffff";
	static final String DFA91_acceptS =
		"\51\uffff\1\3\5\uffff\1\1\1\2\1\4\1\5\1\6\1\7";
	static final String DFA91_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30"
				+ "\1\31\1\32\1\33\1\34\1\35\1\36\1\37\1\40\1\41\1\42\1\43\1\44\1\45"
				+ "\1\46\1\47\4\uffff\1\50\1\51\6\uffff}>";
	static final String[] DFA91_transitionS =
		{
				"\1\22\5\uffff\2\51\6\uffff\2\51\5\uffff\1\55\1\56\23\uffff"
						+ "\1\43\1\23\1\uffff\1\24\2\uffff\1\25\1\45\3\uffff\1\26\1\47"
						+ "\1\50\1\uffff\1\27\5\uffff\1\3\2\uffff\1\30\6\uffff\1\31\4\uffff"
						+ "\1\32\1\uffff\1\1\1\10\1\33\12\uffff\1\34\1\uffff\1\35\3\uffff"
						+ "\1\36\2\uffff\1\42\1\uffff\1\2\1\uffff\1\44\1\37\1\40\1\46\1"
						+ "\uffff\1\41\5\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21"
						+ "\1\11\1\4\1\5\1\6\1\7", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "", "", "", "", "\1\uffff",
				"\1\uffff", "", "", "", "", "", "" };

	static final short[] DFA91_eot = DFA.unpackEncodedString(DFA91_eotS);
	static final short[] DFA91_eof = DFA.unpackEncodedString(DFA91_eofS);
	static final char[] DFA91_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA91_minS);
	static final char[] DFA91_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA91_maxS);
	static final short[] DFA91_accept = DFA.unpackEncodedString(DFA91_acceptS);
	static final short[] DFA91_special = DFA
		.unpackEncodedString(DFA91_specialS);
	static final short[][] DFA91_transition;

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

	class DFA91 extends DFA {

		public DFA91(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 91;
			this.eot = DFA91_eot;
			this.eof = DFA91_eof;
			this.min = DFA91_min;
			this.max = DFA91_max;
			this.accept = DFA91_accept;
			this.special = DFA91_special;
			this.transition = DFA91_transition;
		}
		public String getDescription() {
			return "1086:1: statementexpression : ( invocationexpression | objectcreationexpression | assignment | postincrementexpression | postdecrementexpression | preincrementexpression | predecrementexpression );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index91_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred269_CSharp())) {
						s = 48;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

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

					int index91_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

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

					int index91_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

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

					int index91_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

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

					int index91_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index91_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index91_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index91_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index91_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index91_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index91_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index91_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index91_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index91_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index91_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index91_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index91_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index91_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index91_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index91_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index91_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index91_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index91_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index91_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_24);
					if (s >= 0)
						return s;
					break;
				case 24 :
					input.LA(1);

					int index91_25 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_25);
					if (s >= 0)
						return s;
					break;
				case 25 :
					input.LA(1);

					int index91_26 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_26);
					if (s >= 0)
						return s;
					break;
				case 26 :
					input.LA(1);

					int index91_27 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_27);
					if (s >= 0)
						return s;
					break;
				case 27 :
					input.LA(1);

					int index91_28 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_28);
					if (s >= 0)
						return s;
					break;
				case 28 :
					input.LA(1);

					int index91_29 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_29);
					if (s >= 0)
						return s;
					break;
				case 29 :
					input.LA(1);

					int index91_30 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_30);
					if (s >= 0)
						return s;
					break;
				case 30 :
					input.LA(1);

					int index91_31 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_31);
					if (s >= 0)
						return s;
					break;
				case 31 :
					input.LA(1);

					int index91_32 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_32);
					if (s >= 0)
						return s;
					break;
				case 32 :
					input.LA(1);

					int index91_33 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_33);
					if (s >= 0)
						return s;
					break;
				case 33 :
					input.LA(1);

					int index91_34 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_34);
					if (s >= 0)
						return s;
					break;
				case 34 :
					input.LA(1);

					int index91_35 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_35);
					if (s >= 0)
						return s;
					break;
				case 35 :
					input.LA(1);

					int index91_36 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_36);
					if (s >= 0)
						return s;
					break;
				case 36 :
					input.LA(1);

					int index91_37 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_37);
					if (s >= 0)
						return s;
					break;
				case 37 :
					input.LA(1);

					int index91_38 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_38);
					if (s >= 0)
						return s;
					break;
				case 38 :
					input.LA(1);

					int index91_39 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_39);
					if (s >= 0)
						return s;
					break;
				case 39 :
					input.LA(1);

					int index91_40 = input.index();
					input.rewind();
					s = -1;
					if ((synpred268_CSharp())) {
						s = 47;
					}

					else if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred271_CSharp())) {
						s = 49;
					}

					else if ((synpred272_CSharp())) {
						s = 50;
					}

					input.seek(index91_40);
					if (s >= 0)
						return s;
					break;
				case 40 :
					input.LA(1);

					int index91_45 = input.index();
					input.rewind();
					s = -1;
					if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((synpred273_CSharp())) {
						s = 51;
					}

					input.seek(index91_45);
					if (s >= 0)
						return s;
					break;
				case 41 :
					input.LA(1);

					int index91_46 = input.index();
					input.rewind();
					s = -1;
					if ((synpred270_CSharp())) {
						s = 41;
					}

					else if ((true)) {
						s = 52;
					}

					input.seek(index91_46);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 91, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA96_eotS = "\5\uffff";
	static final String DFA96_eofS = "\5\uffff";
	static final String DFA96_minS = "\1\u00b2\1\uffff\1\u00ad\1\uffff\1\u00ad";
	static final String DFA96_maxS = "\1\u0137\1\uffff\1\u00ba\1\uffff\1\u00ba";
	static final String DFA96_acceptS = "\1\uffff\1\2\1\uffff\1\1\1\uffff";
	static final String DFA96_specialS = "\5\uffff}>";
	static final String[] DFA96_transitionS =
		{
				"\1\1\3\uffff\1\1\4\uffff\3\1\6\uffff\2\1\5\uffff\2\1\23\uffff"
						+ "\4\1\1\3\1\uffff\2\1\1\uffff\3\1\1\2\3\1\5\uffff\1\1\2\uffff"
						+ "\5\1\2\uffff\1\1\3\uffff\2\1\1\uffff\3\1\11\uffff\2\1\1\uffff"
						+ "\1\1\3\uffff\1\1\1\uffff\11\1\1\uffff\2\1\3\uffff\16\1",
				"", "\5\4\4\uffff\1\1\3\uffff\1\3", "",
				"\5\4\4\uffff\1\1\3\uffff\1\3" };

	static final short[] DFA96_eot = DFA.unpackEncodedString(DFA96_eotS);
	static final short[] DFA96_eof = DFA.unpackEncodedString(DFA96_eofS);
	static final char[] DFA96_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA96_minS);
	static final char[] DFA96_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA96_maxS);
	static final short[] DFA96_accept = DFA.unpackEncodedString(DFA96_acceptS);
	static final short[] DFA96_special = DFA
		.unpackEncodedString(DFA96_specialS);
	static final short[][] DFA96_transition;

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

	class DFA96 extends DFA {

		public DFA96(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 96;
			this.eot = DFA96_eot;
			this.eof = DFA96_eof;
			this.min = DFA96_min;
			this.max = DFA96_max;
			this.accept = DFA96_accept;
			this.special = DFA96_special;
			this.transition = DFA96_transition;
		}
		public String getDescription() {
			return "()+ loopback of 1129:9: ( switchlabel )+";
		}
	}
	static final String DFA102_eotS = "\60\uffff";
	static final String DFA102_eofS = "\60\uffff";
	static final String DFA102_minS = "\1\u00b6\30\0\27\uffff";
	static final String DFA102_maxS = "\1\u0137\30\0\27\uffff";
	static final String DFA102_acceptS = "\31\uffff\1\2\25\uffff\1\1";
	static final String DFA102_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\27\uffff}>";
	static final String[] DFA102_transitionS =
		{
				"\1\31\5\uffff\2\31\6\uffff\2\31\5\uffff\2\31\23\uffff\1\31"
						+ "\1\26\1\uffff\1\13\2\uffff\1\22\1\31\3\uffff\1\25\2\31\1\uffff"
						+ "\1\24\5\uffff\1\31\2\uffff\1\23\6\uffff\1\16\4\uffff\1\20\1"
						+ "\uffff\2\31\1\27\12\uffff\1\12\1\uffff\1\14\3\uffff\1\30\2\uffff"
						+ "\1\31\1\uffff\1\31\1\uffff\1\31\1\17\1\21\1\31\1\uffff\1\15"
						+ "\5\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1\4\31",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "" };

	static final short[] DFA102_eot = DFA.unpackEncodedString(DFA102_eotS);
	static final short[] DFA102_eof = DFA.unpackEncodedString(DFA102_eofS);
	static final char[] DFA102_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA102_minS);
	static final char[] DFA102_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA102_maxS);
	static final short[] DFA102_accept = DFA
		.unpackEncodedString(DFA102_acceptS);
	static final short[] DFA102_special = DFA
		.unpackEncodedString(DFA102_specialS);
	static final short[][] DFA102_transition;

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

	class DFA102 extends DFA {

		public DFA102(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 102;
			this.eot = DFA102_eot;
			this.eof = DFA102_eof;
			this.min = DFA102_min;
			this.max = DFA102_max;
			this.accept = DFA102_accept;
			this.special = DFA102_special;
			this.transition = DFA102_transition;
		}
		public String getDescription() {
			return "1163:1: forinitializer : ( localvariabledeclaration -> ^( ForInitializer localvariabledeclaration ) | statementexpressionlist -> ^( ForInitializer statementexpressionlist ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index102_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index102_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index102_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index102_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index102_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index102_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index102_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index102_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index102_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index102_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index102_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index102_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index102_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index102_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index102_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index102_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index102_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index102_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index102_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index102_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index102_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index102_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index102_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index102_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred286_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index102_24);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 102, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA105_eotS = "\6\uffff";
	static final String DFA105_eofS = "\6\uffff";
	static final String DFA105_minS = "\1\u00fb\2\u00ad\3\uffff";
	static final String DFA105_maxS = "\1\u00fb\2\u0133\3\uffff";
	static final String DFA105_acceptS = "\3\uffff\1\2\1\3\1\1";
	static final String DFA105_specialS = "\6\uffff}>";
	static final String[] DFA105_transitionS = { "\1\1",
			"\5\2\62\uffff\1\3\7\uffff\1\4\76\uffff\11\5",
			"\5\2\62\uffff\1\3\7\uffff\1\4\76\uffff\11\5", "", "", "" };

	static final short[] DFA105_eot = DFA.unpackEncodedString(DFA105_eotS);
	static final short[] DFA105_eof = DFA.unpackEncodedString(DFA105_eofS);
	static final char[] DFA105_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA105_minS);
	static final char[] DFA105_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA105_maxS);
	static final short[] DFA105_accept = DFA
		.unpackEncodedString(DFA105_acceptS);
	static final short[] DFA105_special = DFA
		.unpackEncodedString(DFA105_specialS);
	static final short[][] DFA105_transition;

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

	class DFA105 extends DFA {

		public DFA105(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 105;
			this.eot = DFA105_eot;
			this.eof = DFA105_eof;
			this.min = DFA105_min;
			this.max = DFA105_max;
			this.accept = DFA105_accept;
			this.special = DFA105_special;
			this.transition = DFA105_transition;
		}
		public String getDescription() {
			return "1207:1: gotostatement : ( gOTO identifier sEMICOLON -> ^( GotoStatement gOTO identifier sEMICOLON ) | gOTO cASE constantexpression sEMICOLON -> ^( GotoStatement gOTO cASE constantexpression sEMICOLON ) | gOTO dEFAULT sEMICOLON -> ^( GotoStatement gOTO dEFAULT sEMICOLON ) );";
		}
	}
	static final String DFA110_eotS = "\5\uffff";
	static final String DFA110_eofS = "\5\uffff";
	static final String DFA110_minS = "\1\u00e5\2\u00ad\2\uffff";
	static final String DFA110_maxS = "\1\u00e5\2\u00b6\2\uffff";
	static final String DFA110_acceptS = "\3\uffff\1\2\1\1";
	static final String DFA110_specialS = "\5\uffff}>";
	static final String[] DFA110_transitionS = { "\1\1",
			"\5\2\1\3\3\uffff\1\4", "\5\2\1\3\3\uffff\1\4", "", "" };

	static final short[] DFA110_eot = DFA.unpackEncodedString(DFA110_eotS);
	static final short[] DFA110_eof = DFA.unpackEncodedString(DFA110_eofS);
	static final char[] DFA110_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA110_minS);
	static final char[] DFA110_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA110_maxS);
	static final short[] DFA110_accept = DFA
		.unpackEncodedString(DFA110_acceptS);
	static final short[] DFA110_special = DFA
		.unpackEncodedString(DFA110_specialS);
	static final short[][] DFA110_transition;

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

	class DFA110 extends DFA {

		public DFA110(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 110;
			this.eot = DFA110_eot;
			this.eof = DFA110_eof;
			this.min = DFA110_min;
			this.max = DFA110_max;
			this.accept = DFA110_accept;
			this.special = DFA110_special;
			this.transition = DFA110_transition;
		}
		public String getDescription() {
			return "1234:9: ( specificcatchclauses )?";
		}
	}
	static final String DFA112_eotS = "\5\uffff";
	static final String DFA112_eofS = "\1\2\4\uffff";
	static final String DFA112_minS =
		"\1\u00b2\1\u00ad\1\uffff\1\u00ad\1\uffff";
	static final String DFA112_maxS =
		"\1\u0137\1\u00b6\1\uffff\1\u00b6\1\uffff";
	static final String DFA112_acceptS = "\2\uffff\1\2\1\uffff\1\1";
	static final String DFA112_specialS = "\5\uffff}>";
	static final String[] DFA112_transitionS =
		{
				"\2\2\2\uffff\1\2\4\uffff\3\2\6\uffff\2\2\5\uffff\2\2\23\uffff"
						+ "\5\2\1\1\2\2\1\uffff\10\2\4\uffff\2\2\1\uffff\5\2\2\uffff\1"
						+ "\2\3\uffff\2\2\1\uffff\3\2\11\uffff\2\2\1\uffff\1\2\3\uffff"
						+ "\1\2\1\uffff\11\2\1\uffff\2\2\3\uffff\16\2",
				"\5\3\1\2\3\uffff\1\4", "", "\5\3\1\2\3\uffff\1\4", "" };

	static final short[] DFA112_eot = DFA.unpackEncodedString(DFA112_eotS);
	static final short[] DFA112_eof = DFA.unpackEncodedString(DFA112_eofS);
	static final char[] DFA112_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA112_minS);
	static final char[] DFA112_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA112_maxS);
	static final short[] DFA112_accept = DFA
		.unpackEncodedString(DFA112_acceptS);
	static final short[] DFA112_special = DFA
		.unpackEncodedString(DFA112_specialS);
	static final short[][] DFA112_transition;

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

	class DFA112 extends DFA {

		public DFA112(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 112;
			this.eot = DFA112_eot;
			this.eof = DFA112_eof;
			this.min = DFA112_min;
			this.max = DFA112_max;
			this.accept = DFA112_accept;
			this.special = DFA112_special;
			this.transition = DFA112_transition;
		}
		public String getDescription() {
			return "()+ loopback of 1239:9: ( specificcatchclause )+";
		}
	}
	static final String DFA114_eotS = "\60\uffff";
	static final String DFA114_eofS = "\60\uffff";
	static final String DFA114_minS = "\1\u00b6\30\0\27\uffff";
	static final String DFA114_maxS = "\1\u0137\30\0\27\uffff";
	static final String DFA114_acceptS = "\31\uffff\1\2\25\uffff\1\1";
	static final String DFA114_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\27\uffff}>";
	static final String[] DFA114_transitionS =
		{
				"\1\31\5\uffff\2\31\6\uffff\2\31\5\uffff\2\31\23\uffff\1\31"
						+ "\1\26\1\uffff\1\13\2\uffff\1\22\1\31\3\uffff\1\25\2\31\1\uffff"
						+ "\1\24\5\uffff\1\31\2\uffff\1\23\6\uffff\1\16\4\uffff\1\20\1"
						+ "\uffff\2\31\1\27\12\uffff\1\12\1\uffff\1\14\3\uffff\1\30\2\uffff"
						+ "\1\31\1\uffff\1\31\1\uffff\1\31\1\17\1\21\1\31\1\uffff\1\15"
						+ "\5\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1\4\31",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "" };

	static final short[] DFA114_eot = DFA.unpackEncodedString(DFA114_eotS);
	static final short[] DFA114_eof = DFA.unpackEncodedString(DFA114_eofS);
	static final char[] DFA114_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA114_minS);
	static final char[] DFA114_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA114_maxS);
	static final short[] DFA114_accept = DFA
		.unpackEncodedString(DFA114_acceptS);
	static final short[] DFA114_special = DFA
		.unpackEncodedString(DFA114_specialS);
	static final short[][] DFA114_transition;

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

	class DFA114 extends DFA {

		public DFA114(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 114;
			this.eot = DFA114_eot;
			this.eof = DFA114_eof;
			this.min = DFA114_min;
			this.max = DFA114_max;
			this.accept = DFA114_accept;
			this.special = DFA114_special;
			this.transition = DFA114_transition;
		}
		public String getDescription() {
			return "1278:1: resourceacquisition : ( localvariabledeclaration | expression );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index114_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index114_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index114_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index114_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

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

					int index114_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index114_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index114_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index114_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index114_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index114_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index114_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index114_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index114_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index114_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index114_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index114_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index114_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index114_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index114_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index114_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index114_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index114_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index114_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index114_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred302_CSharp())) {
						s = 47;
					}

					else if ((true)) {
						s = 25;
					}

					input.seek(index114_24);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 114, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA115_eotS = "\5\uffff";
	static final String DFA115_eofS = "\5\uffff";
	static final String DFA115_minS = "\1\u0132\2\u00ad\2\uffff";
	static final String DFA115_maxS = "\1\u0132\2\u0112\2\uffff";
	static final String DFA115_acceptS = "\3\uffff\1\1\1\2";
	static final String DFA115_specialS = "\5\uffff}>";
	static final String[] DFA115_transitionS = { "\1\1",
			"\5\2\60\uffff\1\4\57\uffff\1\3", "\5\2\60\uffff\1\4\57\uffff\1\3",
			"", "" };

	static final short[] DFA115_eot = DFA.unpackEncodedString(DFA115_eotS);
	static final short[] DFA115_eof = DFA.unpackEncodedString(DFA115_eofS);
	static final char[] DFA115_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA115_minS);
	static final char[] DFA115_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA115_maxS);
	static final short[] DFA115_accept = DFA
		.unpackEncodedString(DFA115_acceptS);
	static final short[] DFA115_special = DFA
		.unpackEncodedString(DFA115_specialS);
	static final short[][] DFA115_transition;

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

	class DFA115 extends DFA {

		public DFA115(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 115;
			this.eot = DFA115_eot;
			this.eof = DFA115_eof;
			this.min = DFA115_min;
			this.max = DFA115_max;
			this.accept = DFA115_accept;
			this.special = DFA115_special;
			this.transition = DFA115_transition;
		}
		public String getDescription() {
			return "1283:1: yieldstatement : ( yIELD rETURN expression sEMICOLON -> ^( YieldStatement yIELD rETURN expression sEMICOLON ) | yIELD bREAK sEMICOLON -> ^( YieldStatement yIELD bREAK sEMICOLON ) );";
		}
	}
	static final String DFA123_eotS = "\27\uffff";
	static final String DFA123_eofS = "\27\uffff";
	static final String DFA123_minS = "\1\u0126\14\u00ad\2\uffff\10\u00ad";
	static final String DFA123_maxS =
		"\1\u0126\2\u0133\12\u00ca\2\uffff\10\u00ca";
	static final String DFA123_acceptS = "\15\uffff\1\1\1\2\10\uffff";
	static final String DFA123_specialS = "\27\uffff}>";
	static final String[] DFA123_transitionS = {
			"\1\1",
			"\5\2\171\uffff\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\3",
			"\5\2\171\uffff\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\3",
			"\5\14\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\17\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\20\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\21\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\22\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\23\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\24\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\25\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\26\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\14\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"",
			"",
			"\5\17\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\20\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\21\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\22\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\23\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\24\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\25\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16",
			"\5\26\6\uffff\1\16\2\uffff\1\16\12\uffff\1\15\1\16\2\uffff"
					+ "\1\16" };

	static final short[] DFA123_eot = DFA.unpackEncodedString(DFA123_eotS);
	static final short[] DFA123_eof = DFA.unpackEncodedString(DFA123_eofS);
	static final char[] DFA123_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA123_minS);
	static final char[] DFA123_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA123_maxS);
	static final short[] DFA123_accept = DFA
		.unpackEncodedString(DFA123_acceptS);
	static final short[] DFA123_special = DFA
		.unpackEncodedString(DFA123_specialS);
	static final short[][] DFA123_transition;

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

	class DFA123 extends DFA {

		public DFA123(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 123;
			this.eot = DFA123_eot;
			this.eof = DFA123_eof;
			this.min = DFA123_min;
			this.max = DFA123_max;
			this.accept = DFA123_accept;
			this.special = DFA123_special;
			this.transition = DFA123_transition;
		}
		public String getDescription() {
			return "1331:1: usingdirective : ( usingaliasdirective | usingnamespacedirective );";
		}
	}
	static final String DFA126_eotS = "\20\uffff";
	static final String DFA126_eofS = "\20\uffff";
	static final String DFA126_minS = "\1\u00b4\6\0\3\uffff\1\0\5\uffff";
	static final String DFA126_maxS = "\1\u012e\6\0\3\uffff\1\0\5\uffff";
	static final String DFA126_acceptS =
		"\7\uffff\3\1\1\uffff\1\1\1\2\1\3\1\4\1\5";
	static final String DFA126_specialS =
		"\1\0\1\1\1\2\1\3\1\4\1\5\1\6\3\uffff\1\7\5\uffff}>";
	static final String[] DFA126_transitionS =
		{
				"\1\1\51\uffff\1\7\11\uffff\1\13\4\uffff\1\17\3\uffff\1\16\16"
						+ "\uffff\1\15\1\5\4\uffff\1\2\6\uffff\1\6\1\4\1\3\4\uffff\1\10"
						+ "\3\uffff\1\11\1\uffff\1\14\23\uffff\1\12",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "", "", "", "\1\uffff", "", "", "", "", "" };

	static final short[] DFA126_eot = DFA.unpackEncodedString(DFA126_eotS);
	static final short[] DFA126_eof = DFA.unpackEncodedString(DFA126_eofS);
	static final char[] DFA126_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA126_minS);
	static final char[] DFA126_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA126_maxS);
	static final short[] DFA126_accept = DFA
		.unpackEncodedString(DFA126_acceptS);
	static final short[] DFA126_special = DFA
		.unpackEncodedString(DFA126_specialS);
	static final short[][] DFA126_transition;

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

	class DFA126 extends DFA {

		public DFA126(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 126;
			this.eot = DFA126_eot;
			this.eof = DFA126_eof;
			this.min = DFA126_min;
			this.max = DFA126_max;
			this.accept = DFA126_accept;
			this.special = DFA126_special;
			this.transition = DFA126_transition;
		}
		public String getDescription() {
			return "1357:1: typedeclaration : ( ( ( attributes )? ( classmodifiers )? ( pARTIAL )? cLASS )=> classdeclaration -> ^( TypeDeclaration classdeclaration ) | ( ( attributes )? ( structmodifiers )? ( pARTIAL )? sTRUCT )=> structdeclaration -> ^( TypeDeclaration structdeclaration ) | ( ( attributes )? ( interfacemodifiers )? ( pARTIAL )? iNTERFACE )=> interfacedeclaration -> ^( TypeDeclaration interfacedeclaration ) | ( ( attributes )? ( enummodifiers )? eNUM )=> enumdeclaration -> ^( TypeDeclaration enumdeclaration ) | ( ( attributes )? ( delegatemodifiers )? dELEGATE )=> delegatedeclaration -> ^( TypeDeclaration delegatedeclaration ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					int LA126_0 = input.LA(1);

					int index126_0 = input.index();
					input.rewind();
					s = -1;
					if ((LA126_0 == LBRACKET)) {
						s = 1;
					}

					else if ((LA126_0 == NEW)) {
						s = 2;
					}

					else if ((LA126_0 == PUBLIC)) {
						s = 3;
					}

					else if ((LA126_0 == PROTECTED)) {
						s = 4;
					}

					else if ((LA126_0 == INTERNAL)) {
						s = 5;
					}

					else if ((LA126_0 == PRIVATE)) {
						s = 6;
					}

					else if ((LA126_0 == ABSTRACT) && (synpred318_CSharp())) {
						s = 7;
					}

					else if ((LA126_0 == SEALED) && (synpred318_CSharp())) {
						s = 8;
					}

					else if ((LA126_0 == STATIC) && (synpred318_CSharp())) {
						s = 9;
					}

					else if ((LA126_0 == PARTIAL)) {
						s = 10;
					}

					else if ((LA126_0 == CLASS) && (synpred318_CSharp())) {
						s = 11;
					}

					else if ((LA126_0 == STRUCT) && (synpred322_CSharp())) {
						s = 12;
					}

					else if ((LA126_0 == INTERFACE) && (synpred326_CSharp())) {
						s = 13;
					}

					else if ((LA126_0 == ENUM) && (synpred329_CSharp())) {
						s = 14;
					}

					else if ((LA126_0 == DELEGATE) && (synpred332_CSharp())) {
						s = 15;
					}

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

					int index126_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred318_CSharp())) {
						s = 11;
					}

					else if ((synpred322_CSharp())) {
						s = 12;
					}

					else if ((synpred326_CSharp())) {
						s = 13;
					}

					else if ((synpred329_CSharp())) {
						s = 14;
					}

					else if ((synpred332_CSharp())) {
						s = 15;
					}

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

					int index126_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred318_CSharp())) {
						s = 11;
					}

					else if ((synpred322_CSharp())) {
						s = 12;
					}

					else if ((synpred326_CSharp())) {
						s = 13;
					}

					else if ((synpred329_CSharp())) {
						s = 14;
					}

					else if ((synpred332_CSharp())) {
						s = 15;
					}

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

					int index126_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred318_CSharp())) {
						s = 11;
					}

					else if ((synpred322_CSharp())) {
						s = 12;
					}

					else if ((synpred326_CSharp())) {
						s = 13;
					}

					else if ((synpred329_CSharp())) {
						s = 14;
					}

					else if ((synpred332_CSharp())) {
						s = 15;
					}

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

					int index126_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred318_CSharp())) {
						s = 11;
					}

					else if ((synpred322_CSharp())) {
						s = 12;
					}

					else if ((synpred326_CSharp())) {
						s = 13;
					}

					else if ((synpred329_CSharp())) {
						s = 14;
					}

					else if ((synpred332_CSharp())) {
						s = 15;
					}

					input.seek(index126_4);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index126_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred318_CSharp())) {
						s = 11;
					}

					else if ((synpred322_CSharp())) {
						s = 12;
					}

					else if ((synpred326_CSharp())) {
						s = 13;
					}

					else if ((synpred329_CSharp())) {
						s = 14;
					}

					else if ((synpred332_CSharp())) {
						s = 15;
					}

					input.seek(index126_5);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index126_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred318_CSharp())) {
						s = 11;
					}

					else if ((synpred322_CSharp())) {
						s = 12;
					}

					else if ((synpred326_CSharp())) {
						s = 13;
					}

					else if ((synpred329_CSharp())) {
						s = 14;
					}

					else if ((synpred332_CSharp())) {
						s = 15;
					}

					input.seek(index126_6);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index126_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred318_CSharp())) {
						s = 11;
					}

					else if ((synpred322_CSharp())) {
						s = 12;
					}

					else if ((synpred326_CSharp())) {
						s = 13;
					}

					input.seek(index126_10);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 126, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA127_eotS = "\46\uffff";
	static final String DFA127_eofS = "\1\2\45\uffff";
	static final String DFA127_minS = "\1\u00b2\1\0\44\uffff";
	static final String DFA127_maxS = "\1\u0133\1\0\44\uffff";
	static final String DFA127_acceptS = "\2\uffff\1\2\42\uffff\1\1";
	static final String DFA127_specialS = "\1\uffff\1\0\44\uffff}>";
	static final String[] DFA127_transitionS =
		{
				"\12\2\5\uffff\3\2\3\uffff\1\1\2\2\3\uffff\2\2\1\uffff\3\2\12"
						+ "\uffff\1\2\1\uffff\1\2\42\uffff\1\2\6\uffff\1\2\22\uffff\1\2"
						+ "\16\uffff\11\2", "\1\uffff", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA127_eot = DFA.unpackEncodedString(DFA127_eotS);
	static final short[] DFA127_eof = DFA.unpackEncodedString(DFA127_eofS);
	static final char[] DFA127_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA127_minS);
	static final char[] DFA127_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA127_maxS);
	static final short[] DFA127_accept = DFA
		.unpackEncodedString(DFA127_acceptS);
	static final short[] DFA127_special = DFA
		.unpackEncodedString(DFA127_specialS);
	static final short[][] DFA127_transition;

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

	class DFA127 extends DFA {

		public DFA127(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 127;
			this.eot = DFA127_eot;
			this.eof = DFA127_eof;
			this.min = DFA127_min;
			this.max = DFA127_max;
			this.accept = DFA127_accept;
			this.special = DFA127_special;
			this.transition = DFA127_transition;
		}
		public String getDescription() {
			return "1371:49: ( typeargumentlist )?";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index127_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred333_CSharp())) {
						s = 37;
					}

					else if ((true)) {
						s = 2;
					}

					input.seek(index127_1);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 127, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA140_eotS = "\65\uffff";
	static final String DFA140_eofS = "\65\uffff";
	static final String DFA140_minS =
		"\1\u00b4\6\0\1\uffff\1\0\2\uffff\35\0\15\uffff";
	static final String DFA140_maxS =
		"\1\u0133\6\0\1\uffff\1\0\2\uffff\35\0\15\uffff";
	static final String DFA140_acceptS =
		"\7\uffff\1\1\1\uffff\1\2\36\uffff\1\3\1\5\1\11\1\13\4\uffff\1\4"
				+ "\1\6\1\7\1\10\1\12";
	static final String DFA140_specialS =
		"\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\uffff\1\7\2\uffff\1\10\1\11\1\12"
				+ "\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27"
				+ "\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\1\40\1\41\1\42\1\43\1\44"
				+ "\15\uffff}>";
	static final String[] DFA140_transitionS =
		{
				"\1\1\20\uffff\1\52\30\uffff\1\46\2\uffff\1\40\1\uffff\1\25"
						+ "\2\uffff\1\34\1\uffff\1\53\1\7\1\uffff\1\37\1\uffff\1\53\1\uffff"
						+ "\1\36\1\uffff\1\53\1\51\1\uffff\1\47\3\uffff\1\35\6\uffff\1"
						+ "\30\1\53\1\5\2\uffff\1\32\1\uffff\1\2\1\uffff\1\41\2\uffff\1"
						+ "\45\1\uffff\1\6\1\4\1\3\1\11\2\uffff\1\24\1\44\1\26\2\uffff"
						+ "\1\10\1\42\1\53\6\uffff\1\31\1\33\2\uffff\1\27\1\uffff\1\43"
						+ "\1\50\1\11\1\uffff\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1"
						+ "\13", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "", "\1\uffff", "", "",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "", "", "", "",
				"", "", "", "", "", "", "", "", "" };

	static final short[] DFA140_eot = DFA.unpackEncodedString(DFA140_eotS);
	static final short[] DFA140_eof = DFA.unpackEncodedString(DFA140_eofS);
	static final char[] DFA140_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA140_minS);
	static final char[] DFA140_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA140_maxS);
	static final short[] DFA140_accept = DFA
		.unpackEncodedString(DFA140_acceptS);
	static final short[] DFA140_special = DFA
		.unpackEncodedString(DFA140_specialS);
	static final short[][] DFA140_transition;

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

	class DFA140 extends DFA {

		public DFA140(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 140;
			this.eot = DFA140_eot;
			this.eof = DFA140_eof;
			this.min = DFA140_min;
			this.max = DFA140_max;
			this.accept = DFA140_accept;
			this.special = DFA140_special;
			this.transition = DFA140_transition;
		}
		public String getDescription() {
			return "1501:1: classmemberdeclaration : ( ( ( attributes )? ( constantmodifiers )? cONST )=> constantdeclaration -> ^( ClassMemberDeclaration constantdeclaration ) | fielddeclaration -> ^( ClassMemberDeclaration fielddeclaration ) | ( methodheader )=> methoddeclaration -> ^( ClassMemberDeclaration methoddeclaration ) | propertydeclaration -> ^( ClassMemberDeclaration propertydeclaration ) | ( ( attributes )? ( eventmodifiers )? eVENT )=> eventdeclaration -> ^( ClassMemberDeclaration eventdeclaration ) | ( ( attributes )? ( indexermodifiers )? indexerdeclarator )=> indexerdeclaration -> ^( ClassMemberDeclaration indexerdeclaration ) | ( ( attributes )? operatormodifiers operatordeclarator )=> operatordeclaration -> ^( ClassMemberDeclaration operatordeclaration ) | ( ( attributes )? ( constructormodifiers )? constructordeclarator )=> constructordeclaration -> ^( ClassMemberDeclaration constructordeclaration ) | ( ( attributes )? ( eXTERN )? tILDE )=> finalizerdeclaration -> ^( ClassMemberDeclaration finalizerdeclaration ) | ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )=> staticconstructordeclaration -> ^( ClassMemberDeclaration staticconstructordeclaration ) | typedeclaration -> ^( ClassMemberDeclaration typedeclaration ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					int LA140_0 = input.LA(1);

					int index140_0 = input.index();
					input.rewind();
					s = -1;
					if ((LA140_0 == LBRACKET)) {
						s = 1;
					}

					else if ((LA140_0 == NEW)) {
						s = 2;
					}

					else if ((LA140_0 == PUBLIC)) {
						s = 3;
					}

					else if ((LA140_0 == PROTECTED)) {
						s = 4;
					}

					else if ((LA140_0 == INTERNAL)) {
						s = 5;
					}

					else if ((LA140_0 == PRIVATE)) {
						s = 6;
					}

					else if ((LA140_0 == CONST) && (synpred354_CSharp())) {
						s = 7;
					}

					else if ((LA140_0 == STATIC)) {
						s = 8;
					}

					else if ((LA140_0 == READONLY || LA140_0 == VOLATILE)) {
						s = 9;
					}

					else if ((LA140_0 == Ident)) {
						s = 11;
					}

					else if ((LA140_0 == ADD)) {
						s = 12;
					}

					else if ((LA140_0 == ALIAS)) {
						s = 13;
					}

					else if ((LA140_0 == GET)) {
						s = 14;
					}

					else if ((LA140_0 == PARTIAL)) {
						s = 15;
					}

					else if ((LA140_0 == REMOVE)) {
						s = 16;
					}

					else if ((LA140_0 == SET)) {
						s = 17;
					}

					else if ((LA140_0 == WHERE)) {
						s = 18;
					}

					else if ((LA140_0 == YIELD)) {
						s = 19;
					}

					else if ((LA140_0 == SBYTE)) {
						s = 20;
					}

					else if ((LA140_0 == BYTE)) {
						s = 21;
					}

					else if ((LA140_0 == SHORT)) {
						s = 22;
					}

					else if ((LA140_0 == USHORT)) {
						s = 23;
					}

					else if ((LA140_0 == INT)) {
						s = 24;
					}

					else if ((LA140_0 == UINT)) {
						s = 25;
					}

					else if ((LA140_0 == LONG)) {
						s = 26;
					}

					else if ((LA140_0 == ULONG)) {
						s = 27;
					}

					else if ((LA140_0 == CHAR)) {
						s = 28;
					}

					else if ((LA140_0 == FLOAT)) {
						s = 29;
					}

					else if ((LA140_0 == DOUBLE)) {
						s = 30;
					}

					else if ((LA140_0 == DECIMAL)) {
						s = 31;
					}

					else if ((LA140_0 == BOOL)) {
						s = 32;
					}

					else if ((LA140_0 == OBJECT)) {
						s = 33;
					}

					else if ((LA140_0 == STRING)) {
						s = 34;
					}

					else if ((LA140_0 == VIRTUAL)) {
						s = 35;
					}

					else if ((LA140_0 == SEALED)) {
						s = 36;
					}

					else if ((LA140_0 == OVERRIDE)) {
						s = 37;
					}

					else if ((LA140_0 == ABSTRACT)) {
						s = 38;
					}

					else if ((LA140_0 == EXTERN)) {
						s = 39;
					}

					else if ((LA140_0 == VOID) && (synpred356_CSharp())) {
						s = 40;
					}

					else if ((LA140_0 == EVENT) && (synpred360_CSharp())) {
						s = 41;
					}

					else if ((LA140_0 == TILDE) && (synpred371_CSharp())) {
						s = 42;
					}

					else if ((LA140_0 == CLASS || LA140_0 == DELEGATE
							|| LA140_0 == ENUM || LA140_0 == INTERFACE || LA140_0 == STRUCT)) {
						s = 43;
					}

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

					int index140_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred354_CSharp())) {
						s = 7;
					}

					else if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred365_CSharp())) {
						s = 50;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					else if ((synpred371_CSharp())) {
						s = 42;
					}

					else if ((synpred373_CSharp())) {
						s = 52;
					}

					else if ((true)) {
						s = 43;
					}

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

					int index140_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred354_CSharp())) {
						s = 7;
					}

					else if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((true)) {
						s = 43;
					}

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

					int index140_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred354_CSharp())) {
						s = 7;
					}

					else if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred365_CSharp())) {
						s = 50;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					else if ((true)) {
						s = 43;
					}

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

					int index140_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred354_CSharp())) {
						s = 7;
					}

					else if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					else if ((true)) {
						s = 43;
					}

					input.seek(index140_4);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index140_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred354_CSharp())) {
						s = 7;
					}

					else if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					else if ((true)) {
						s = 43;
					}

					input.seek(index140_5);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index140_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred354_CSharp())) {
						s = 7;
					}

					else if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					else if ((true)) {
						s = 43;
					}

					input.seek(index140_6);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index140_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred365_CSharp())) {
						s = 50;
					}

					else if ((synpred373_CSharp())) {
						s = 52;
					}

					else if ((true)) {
						s = 43;
					}

					input.seek(index140_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index140_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					input.seek(index140_11);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index140_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					input.seek(index140_12);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index140_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					input.seek(index140_13);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index140_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					input.seek(index140_14);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index140_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					else if ((true)) {
						s = 43;
					}

					input.seek(index140_15);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index140_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					input.seek(index140_16);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index140_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					input.seek(index140_17);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index140_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					input.seek(index140_18);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index140_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					input.seek(index140_19);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index140_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_20);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index140_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_21);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index140_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_22);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index140_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_23);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index140_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_24);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index140_25 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_25);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index140_26 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_26);
					if (s >= 0)
						return s;
					break;
				case 24 :
					input.LA(1);

					int index140_27 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_27);
					if (s >= 0)
						return s;
					break;
				case 25 :
					input.LA(1);

					int index140_28 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_28);
					if (s >= 0)
						return s;
					break;
				case 26 :
					input.LA(1);

					int index140_29 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_29);
					if (s >= 0)
						return s;
					break;
				case 27 :
					input.LA(1);

					int index140_30 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_30);
					if (s >= 0)
						return s;
					break;
				case 28 :
					input.LA(1);

					int index140_31 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_31);
					if (s >= 0)
						return s;
					break;
				case 29 :
					input.LA(1);

					int index140_32 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_32);
					if (s >= 0)
						return s;
					break;
				case 30 :
					input.LA(1);

					int index140_33 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_33);
					if (s >= 0)
						return s;
					break;
				case 31 :
					input.LA(1);

					int index140_34 = input.index();
					input.rewind();
					s = -1;
					if ((synpred355_CSharp())) {
						s = 9;
					}

					else if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_34);
					if (s >= 0)
						return s;
					break;
				case 32 :
					input.LA(1);

					int index140_35 = input.index();
					input.rewind();
					s = -1;
					if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_35);
					if (s >= 0)
						return s;
					break;
				case 33 :
					input.LA(1);

					int index140_36 = input.index();
					input.rewind();
					s = -1;
					if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((true)) {
						s = 43;
					}

					input.seek(index140_36);
					if (s >= 0)
						return s;
					break;
				case 34 :
					input.LA(1);

					int index140_37 = input.index();
					input.rewind();
					s = -1;
					if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					input.seek(index140_37);
					if (s >= 0)
						return s;
					break;
				case 35 :
					input.LA(1);

					int index140_38 = input.index();
					input.rewind();
					s = -1;
					if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((true)) {
						s = 43;
					}

					input.seek(index140_38);
					if (s >= 0)
						return s;
					break;
				case 36 :
					input.LA(1);

					int index140_39 = input.index();
					input.rewind();
					s = -1;
					if ((synpred356_CSharp())) {
						s = 40;
					}

					else if ((synpred357_CSharp())) {
						s = 48;
					}

					else if ((synpred360_CSharp())) {
						s = 41;
					}

					else if ((synpred363_CSharp())) {
						s = 49;
					}

					else if ((synpred365_CSharp())) {
						s = 50;
					}

					else if ((synpred368_CSharp())) {
						s = 51;
					}

					else if ((synpred371_CSharp())) {
						s = 42;
					}

					else if ((synpred373_CSharp())) {
						s = 52;
					}

					input.seek(index140_39);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 140, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA158_eotS = "\14\uffff";
	static final String DFA158_eofS = "\14\uffff";
	static final String DFA158_minS = "\1\u00de\13\uffff";
	static final String DFA158_maxS = "\1\u0127\13\uffff";
	static final String DFA158_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13";
	static final String DFA158_specialS = "\14\uffff}>";
	static final String[] DFA158_transitionS =
		{
				"\1\12\25\uffff\1\13\14\uffff\1\4\4\uffff\1\1\4\uffff\1\11\1"
						+ "\uffff\1\5\1\3\1\2\4\uffff\1\10\3\uffff\1\6\16\uffff\1\7",
				"", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA158_eot = DFA.unpackEncodedString(DFA158_eotS);
	static final short[] DFA158_eof = DFA.unpackEncodedString(DFA158_eofS);
	static final char[] DFA158_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA158_minS);
	static final char[] DFA158_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA158_maxS);
	static final short[] DFA158_accept = DFA
		.unpackEncodedString(DFA158_acceptS);
	static final short[] DFA158_special = DFA
		.unpackEncodedString(DFA158_specialS);
	static final short[][] DFA158_transition;

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

	class DFA158 extends DFA {

		public DFA158(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 158;
			this.eot = DFA158_eot;
			this.eof = DFA158_eof;
			this.min = DFA158_min;
			this.max = DFA158_max;
			this.accept = DFA158_accept;
			this.special = DFA158_special;
			this.transition = DFA158_transition;
		}
		public String getDescription() {
			return "1782:1: methodmodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN );";
		}
	}
	static final String DFA160_eotS = "\77\uffff";
	static final String DFA160_eofS = "\77\uffff";
	static final String DFA160_minS =
		"\1\u012b\12\u00ad\1\uffff\1\u00ad\1\uffff\61\u00ad";
	static final String DFA160_maxS =
		"\1\u0133\12\u00ca\1\uffff\1\u0133\1\uffff\10\u00ca\1\u0133\12\u00dd"
				+ "\1\u0133\1\u00b8\10\u00dd\1\u0133\11\u00dd\1\u00b8\11\u00dd";
	static final String DFA160_acceptS = "\13\uffff\1\1\1\uffff\1\2\61\uffff";
	static final String DFA160_specialS = "\77\uffff}>";
	static final String[] DFA160_transitionS =
		{
				"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1",
				"\5\12\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\16\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\17\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\20\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\21\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\22\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\23\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\24\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\25\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\12\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"",
				"\5\26\2\uffff\1\15\54\uffff\1\13\1\uffff\1\13\2\uffff\1\13"
						+ "\4\uffff\1\13\3\uffff\1\13\10\uffff\1\13\6\uffff\1\13\4\uffff"
						+ "\1\13\3\uffff\1\13\12\uffff\1\13\1\uffff\1\13\3\uffff\1\13\7"
						+ "\uffff\2\13\2\uffff\1\13\5\uffff\1\30\1\31\1\32\1\33\1\34\1"
						+ "\35\1\36\1\37\1\27",
				"",
				"\5\16\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\17\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\20\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\21\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\22\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\23\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\24\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\25\1\15\3\uffff\1\15\1\uffff\1\13\16\uffff\1\14\2\uffff"
						+ "\1\13",
				"\5\26\2\uffff\1\15\54\uffff\1\13\1\uffff\1\13\2\uffff\1\13"
						+ "\4\uffff\1\13\3\uffff\1\13\10\uffff\1\13\6\uffff\1\13\4\uffff"
						+ "\1\13\3\uffff\1\13\12\uffff\1\13\1\uffff\1\13\3\uffff\1\13\7"
						+ "\uffff\2\13\2\uffff\1\13\5\uffff\1\30\1\31\1\32\1\33\1\34\1"
						+ "\35\1\36\1\37\1\27",
				"\5\40\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\43\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\44\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\45\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\46\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\47\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\50\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\51\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\52\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\40\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\53\2\uffff\1\15\54\uffff\1\13\1\uffff\1\13\2\uffff\1\13"
						+ "\4\uffff\1\13\3\uffff\1\13\10\uffff\1\13\6\uffff\1\13\4\uffff"
						+ "\1\13\3\uffff\1\13\12\uffff\1\13\1\uffff\1\13\3\uffff\1\13\7"
						+ "\uffff\2\13\2\uffff\1\13\5\uffff\1\55\1\56\1\57\1\60\1\61\1"
						+ "\62\1\63\1\64\1\54",
				"\5\65\4\uffff\1\15\1\uffff\1\13",
				"\5\43\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\44\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\45\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\46\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\47\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\50\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\51\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\52\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\53\2\uffff\1\15\54\uffff\1\13\1\uffff\1\13\2\uffff\1\13"
						+ "\4\uffff\1\13\3\uffff\1\13\10\uffff\1\13\6\uffff\1\13\4\uffff"
						+ "\1\13\3\uffff\1\13\12\uffff\1\13\1\uffff\1\13\3\uffff\1\13\7"
						+ "\uffff\2\13\2\uffff\1\13\5\uffff\1\55\1\56\1\57\1\60\1\61\1"
						+ "\62\1\63\1\64\1\54",
				"\5\66\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\67\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\70\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\71\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\72\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\73\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\74\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\75\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\76\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\65\4\uffff\1\15\1\uffff\1\13",
				"\5\66\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\67\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\70\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\71\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\72\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\73\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\74\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\75\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42",
				"\5\76\2\uffff\1\13\3\uffff\1\13\1\41\15\uffff\2\13\1\uffff"
						+ "\1\13\22\uffff\1\42" };

	static final short[] DFA160_eot = DFA.unpackEncodedString(DFA160_eotS);
	static final short[] DFA160_eof = DFA.unpackEncodedString(DFA160_eofS);
	static final char[] DFA160_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA160_minS);
	static final char[] DFA160_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA160_maxS);
	static final short[] DFA160_accept = DFA
		.unpackEncodedString(DFA160_acceptS);
	static final short[] DFA160_special = DFA
		.unpackEncodedString(DFA160_specialS);
	static final short[][] DFA160_transition;

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

	class DFA160 extends DFA {

		public DFA160(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 160;
			this.eot = DFA160_eot;
			this.eof = DFA160_eof;
			this.min = DFA160_min;
			this.max = DFA160_max;
			this.accept = DFA160_accept;
			this.special = DFA160_special;
			this.transition = DFA160_transition;
		}
		public String getDescription() {
			return "1819:9: ( interfacetype dOT )?";
		}
	}
	static final String DFA162_eotS = "\37\uffff";
	static final String DFA162_eofS = "\37\uffff";
	static final String DFA162_minS = "\1\u00b4\33\0\3\uffff";
	static final String DFA162_maxS = "\1\u0133\33\0\3\uffff";
	static final String DFA162_acceptS = "\34\uffff\1\3\1\1\1\2";
	static final String DFA162_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30"
				+ "\1\31\1\32\3\uffff}>";
	static final String[] DFA162_transitionS =
		{
				"\1\1\54\uffff\1\31\1\uffff\1\16\2\uffff\1\25\4\uffff\1\30\3"
						+ "\uffff\1\27\10\uffff\1\26\6\uffff\1\21\4\uffff\1\23\3\uffff"
						+ "\1\32\1\uffff\1\3\1\uffff\1\34\4\uffff\1\2\1\uffff\1\15\1\uffff"
						+ "\1\17\3\uffff\1\33\7\uffff\1\22\1\24\2\uffff\1\20\5\uffff\1"
						+ "\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\4",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "", "", "" };

	static final short[] DFA162_eot = DFA.unpackEncodedString(DFA162_eotS);
	static final short[] DFA162_eof = DFA.unpackEncodedString(DFA162_eofS);
	static final char[] DFA162_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA162_minS);
	static final char[] DFA162_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA162_maxS);
	static final short[] DFA162_accept = DFA
		.unpackEncodedString(DFA162_acceptS);
	static final short[] DFA162_special = DFA
		.unpackEncodedString(DFA162_specialS);
	static final short[][] DFA162_transition;

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

	class DFA162 extends DFA {

		public DFA162(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 162;
			this.eot = DFA162_eot;
			this.eof = DFA162_eof;
			this.min = DFA162_min;
			this.max = DFA162_max;
			this.accept = DFA162_accept;
			this.special = DFA162_special;
			this.transition = DFA162_transition;
		}
		public String getDescription() {
			return "1828:1: formalparameterlist returns [String signature] : ( fixedparameters cOMMA parameterarray | fixedparameters | parameterarray );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index162_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					else if ((true)) {
						s = 28;
					}

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

					int index162_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

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

					int index162_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

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

					int index162_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

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

					int index162_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index162_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index162_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index162_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index162_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index162_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index162_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index162_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index162_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index162_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index162_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index162_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index162_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index162_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index162_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index162_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index162_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index162_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index162_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index162_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_24);
					if (s >= 0)
						return s;
					break;
				case 24 :
					input.LA(1);

					int index162_25 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_25);
					if (s >= 0)
						return s;
					break;
				case 25 :
					input.LA(1);

					int index162_26 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_26);
					if (s >= 0)
						return s;
					break;
				case 26 :
					input.LA(1);

					int index162_27 = input.index();
					input.rewind();
					s = -1;
					if ((synpred413_CSharp())) {
						s = 29;
					}

					else if ((synpred414_CSharp())) {
						s = 30;
					}

					input.seek(index162_27);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 162, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA171_eotS = "\14\uffff";
	static final String DFA171_eofS = "\14\uffff";
	static final String DFA171_minS = "\1\u00de\13\uffff";
	static final String DFA171_maxS = "\1\u0127\13\uffff";
	static final String DFA171_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13";
	static final String DFA171_specialS = "\14\uffff}>";
	static final String[] DFA171_transitionS =
		{
				"\1\12\25\uffff\1\13\14\uffff\1\4\4\uffff\1\1\4\uffff\1\11\1"
						+ "\uffff\1\5\1\3\1\2\4\uffff\1\10\3\uffff\1\6\16\uffff\1\7",
				"", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA171_eot = DFA.unpackEncodedString(DFA171_eotS);
	static final short[] DFA171_eof = DFA.unpackEncodedString(DFA171_eofS);
	static final char[] DFA171_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA171_minS);
	static final char[] DFA171_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA171_maxS);
	static final short[] DFA171_accept = DFA
		.unpackEncodedString(DFA171_acceptS);
	static final short[] DFA171_special = DFA
		.unpackEncodedString(DFA171_specialS);
	static final short[][] DFA171_transition;

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

	class DFA171 extends DFA {

		public DFA171(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 171;
			this.eot = DFA171_eot;
			this.eof = DFA171_eof;
			this.min = DFA171_min;
			this.max = DFA171_max;
			this.accept = DFA171_accept;
			this.special = DFA171_special;
			this.transition = DFA171_transition;
		}
		public String getDescription() {
			return "1889:1: propertymodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN );";
		}
	}
	static final String DFA179_eotS = "\12\uffff";
	static final String DFA179_eofS =
		"\1\uffff\1\6\1\10\1\uffff\1\6\2\uffff\1\10\2\uffff";
	static final String DFA179_minS =
		"\1\u0101\2\u00ad\1\uffff\1\u00ad\2\uffff\1\u00ad\2\uffff";
	static final String DFA179_maxS =
		"\1\u010e\2\u0130\1\uffff\1\u0130\2\uffff\1\u0130\2\uffff";
	static final String DFA179_acceptS =
		"\3\uffff\1\3\1\uffff\1\4\1\1\1\uffff\1\2\1\5";
	static final String DFA179_specialS = "\12\uffff}>";
	static final String[] DFA179_transitionS = { "\1\2\13\uffff\1\3\1\1",
			"\5\4\117\uffff\1\5\53\uffff\1\6\2\uffff\1\6",
			"\5\7\134\uffff\1\11\36\uffff\1\10\2\uffff\1\10", "",
			"\5\4\117\uffff\1\5\53\uffff\1\6\2\uffff\1\6", "", "",
			"\5\7\134\uffff\1\11\36\uffff\1\10\2\uffff\1\10", "", "" };

	static final short[] DFA179_eot = DFA.unpackEncodedString(DFA179_eotS);
	static final short[] DFA179_eof = DFA.unpackEncodedString(DFA179_eofS);
	static final char[] DFA179_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA179_minS);
	static final char[] DFA179_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA179_maxS);
	static final short[] DFA179_accept = DFA
		.unpackEncodedString(DFA179_acceptS);
	static final short[] DFA179_special = DFA
		.unpackEncodedString(DFA179_specialS);
	static final short[][] DFA179_transition;

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

	class DFA179 extends DFA {

		public DFA179(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 179;
			this.eot = DFA179_eot;
			this.eof = DFA179_eof;
			this.min = DFA179_min;
			this.max = DFA179_max;
			this.accept = DFA179_accept;
			this.special = DFA179_special;
			this.transition = DFA179_transition;
		}
		public String getDescription() {
			return "1918:1: accessormodifier : ( pROTECTED -> ^( Modifiers pROTECTED ) | iNTERNAL -> ^( Modifiers iNTERNAL ) | pRIVATE -> ^( Modifiers pRIVATE ) | pROTECTED iNTERNAL -> ^( Modifiers pROTECTED iNTERNAL ) | iNTERNAL pROTECTED -> ^( Modifiers iNTERNAL pROTECTED ) );";
		}
	}
	static final String DFA185_eotS = "\20\uffff";
	static final String DFA185_eofS = "\20\uffff";
	static final String DFA185_minS = "\1\u00b4\15\0\2\uffff";
	static final String DFA185_maxS = "\1\u0127\15\0\2\uffff";
	static final String DFA185_acceptS = "\16\uffff\1\1\1\2";
	static final String DFA185_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\2\uffff}>";
	static final String[] DFA185_transitionS =
		{
				"\1\1\51\uffff\1\13\23\uffff\1\15\1\uffff\1\14\14\uffff\1\5"
						+ "\4\uffff\1\2\4\uffff\1\12\1\uffff\1\6\1\4\1\3\4\uffff\1\11\3"
						+ "\uffff\1\7\16\uffff\1\10", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "", "" };

	static final short[] DFA185_eot = DFA.unpackEncodedString(DFA185_eotS);
	static final short[] DFA185_eof = DFA.unpackEncodedString(DFA185_eofS);
	static final char[] DFA185_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA185_minS);
	static final char[] DFA185_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA185_maxS);
	static final short[] DFA185_accept = DFA
		.unpackEncodedString(DFA185_acceptS);
	static final short[] DFA185_special = DFA
		.unpackEncodedString(DFA185_specialS);
	static final short[][] DFA185_transition;

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

	class DFA185 extends DFA {

		public DFA185(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 185;
			this.eot = DFA185_eot;
			this.eof = DFA185_eof;
			this.min = DFA185_min;
			this.max = DFA185_max;
			this.accept = DFA185_accept;
			this.special = DFA185_special;
			this.transition = DFA185_transition;
		}
		public String getDescription() {
			return "1931:1: eventdeclaration returns [String name] : ( ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON -> ^( Event ( attributes )? ( eventmodifiers )? eVENT type variabledeclarators sEMICOLON ) | ( attributes )? ( eventmodifiers )? eVENT type membername lBRACE eventaccessordeclarations rBRACE -> ^( Event ( attributes )? ( eventmodifiers )? eVENT type membername ^( AccessorDeclarations lBRACE eventaccessordeclarations rBRACE ) ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index185_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

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

					int index185_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

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

					int index185_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

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

					int index185_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

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

					int index185_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index185_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index185_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index185_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index185_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index185_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index185_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index185_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index185_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred447_CSharp())) {
						s = 14;
					}

					else if ((true)) {
						s = 15;
					}

					input.seek(index185_13);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 185, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA187_eotS = "\14\uffff";
	static final String DFA187_eofS = "\14\uffff";
	static final String DFA187_minS = "\1\u00de\13\uffff";
	static final String DFA187_maxS = "\1\u0127\13\uffff";
	static final String DFA187_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13";
	static final String DFA187_specialS = "\14\uffff}>";
	static final String[] DFA187_transitionS =
		{
				"\1\12\25\uffff\1\13\14\uffff\1\4\4\uffff\1\1\4\uffff\1\11\1"
						+ "\uffff\1\5\1\3\1\2\4\uffff\1\10\3\uffff\1\6\16\uffff\1\7",
				"", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA187_eot = DFA.unpackEncodedString(DFA187_eotS);
	static final short[] DFA187_eof = DFA.unpackEncodedString(DFA187_eofS);
	static final char[] DFA187_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA187_minS);
	static final char[] DFA187_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA187_maxS);
	static final short[] DFA187_accept = DFA
		.unpackEncodedString(DFA187_acceptS);
	static final short[] DFA187_special = DFA
		.unpackEncodedString(DFA187_specialS);
	static final short[][] DFA187_transition;

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

	class DFA187 extends DFA {

		public DFA187(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 187;
			this.eot = DFA187_eot;
			this.eof = DFA187_eof;
			this.min = DFA187_min;
			this.max = DFA187_max;
			this.accept = DFA187_accept;
			this.special = DFA187_special;
			this.transition = DFA187_transition;
		}
		public String getDescription() {
			return "1949:1: eventmodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | sTATIC | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN );";
		}
	}
	static final String DFA194_eotS = "\13\uffff";
	static final String DFA194_eofS = "\13\uffff";
	static final String DFA194_minS = "\1\u00de\12\uffff";
	static final String DFA194_maxS = "\1\u0127\12\uffff";
	static final String DFA194_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12";
	static final String DFA194_specialS = "\13\uffff}>";
	static final String[] DFA194_transitionS = {
			"\1\11\25\uffff\1\12\14\uffff\1\4\4\uffff\1\1\4\uffff\1\10\1"
					+ "\uffff\1\5\1\3\1\2\4\uffff\1\7\22\uffff\1\6", "", "",
			"", "", "", "", "", "", "", "" };

	static final short[] DFA194_eot = DFA.unpackEncodedString(DFA194_eotS);
	static final short[] DFA194_eof = DFA.unpackEncodedString(DFA194_eofS);
	static final char[] DFA194_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA194_minS);
	static final char[] DFA194_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA194_maxS);
	static final short[] DFA194_accept = DFA
		.unpackEncodedString(DFA194_acceptS);
	static final short[] DFA194_special = DFA
		.unpackEncodedString(DFA194_specialS);
	static final short[][] DFA194_transition;

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

	class DFA194 extends DFA {

		public DFA194(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 194;
			this.eot = DFA194_eot;
			this.eof = DFA194_eof;
			this.min = DFA194_min;
			this.max = DFA194_max;
			this.accept = DFA194_accept;
			this.special = DFA194_special;
			this.transition = DFA194_transition;
		}
		public String getDescription() {
			return "1995:1: indexermodifier : ( nEW | pUBLIC | pROTECTED | iNTERNAL | pRIVATE | vIRTUAL | sEALED | oVERRIDE | aBSTRACT | eXTERN );";
		}
	}
	static final String DFA199_eotS = "\35\uffff";
	static final String DFA199_eofS = "\35\uffff";
	static final String DFA199_minS = "\1\u00e1\30\0\4\uffff";
	static final String DFA199_maxS = "\1\u0133\30\0\4\uffff";
	static final String DFA199_acceptS = "\31\uffff\1\3\1\uffff\1\1\1\2";
	static final String DFA199_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\4\uffff}>";
	static final String[] DFA199_transitionS =
		{
				"\1\26\1\uffff\1\13\2\uffff\1\22\4\uffff\1\25\3\uffff\1\24\3"
						+ "\uffff\1\31\4\uffff\1\23\4\uffff\1\31\1\uffff\1\16\4\uffff\1"
						+ "\20\3\uffff\1\27\12\uffff\1\12\1\uffff\1\14\3\uffff\1\30\7\uffff"
						+ "\1\17\1\21\2\uffff\1\15\5\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10"
						+ "\1\11\1\1", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "", "", "", "" };

	static final short[] DFA199_eot = DFA.unpackEncodedString(DFA199_eotS);
	static final short[] DFA199_eof = DFA.unpackEncodedString(DFA199_eofS);
	static final char[] DFA199_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA199_minS);
	static final char[] DFA199_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA199_maxS);
	static final short[] DFA199_accept = DFA
		.unpackEncodedString(DFA199_acceptS);
	static final short[] DFA199_special = DFA
		.unpackEncodedString(DFA199_specialS);
	static final short[][] DFA199_transition;

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

	class DFA199 extends DFA {

		public DFA199(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 199;
			this.eot = DFA199_eot;
			this.eof = DFA199_eof;
			this.min = DFA199_min;
			this.max = DFA199_max;
			this.accept = DFA199_accept;
			this.special = DFA199_special;
			this.transition = DFA199_transition;
		}
		public String getDescription() {
			return "2053:1: operatordeclarator returns [String signature] : ( unaryoperatordeclarator -> ^( UnaryOperatorDeclarator unaryoperatordeclarator ) | binaryoperatordeclarator -> ^( BinaryOperatorDeclarator binaryoperatordeclarator ) | conversionoperatordeclarator -> ^( ConversionOperatorDeclarator conversionoperatordeclarator ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index199_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

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

					int index199_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

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

					int index199_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

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

					int index199_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

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

					int index199_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index199_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index199_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index199_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index199_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index199_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index199_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index199_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index199_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index199_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index199_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index199_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index199_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index199_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index199_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index199_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index199_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index199_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index199_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index199_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred481_CSharp())) {
						s = 27;
					}

					else if ((synpred482_CSharp())) {
						s = 28;
					}

					input.seek(index199_24);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 199, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA201_eotS = "\21\uffff";
	static final String DFA201_eofS = "\21\uffff";
	static final String DFA201_minS = "\1\u00bc\10\uffff\1\u00ad\7\uffff";
	static final String DFA201_maxS = "\1\u00dd\10\uffff\1\u00dd\7\uffff";
	static final String DFA201_acceptS =
		"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\uffff\1\12\1\13\1\15"
				+ "\1\17\1\11\1\16\1\14";
	static final String DFA201_specialS = "\21\uffff}>";
	static final String[] DFA201_transitionS = {
			"\1\1\1\uffff\1\2\1\3\1\4\1\5\1\6\1\7\3\uffff\1\14\10\uffff"
					+ "\1\12\1\13\1\15\10\uffff\1\10\1\uffff\1\11", "", "", "",
			"", "", "", "", "",
			"\5\20\4\uffff\1\20\17\uffff\1\17\26\uffff\1\16", "", "", "", "",
			"", "", "" };

	static final short[] DFA201_eot = DFA.unpackEncodedString(DFA201_eotS);
	static final short[] DFA201_eof = DFA.unpackEncodedString(DFA201_eofS);
	static final char[] DFA201_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA201_minS);
	static final char[] DFA201_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA201_maxS);
	static final short[] DFA201_accept = DFA
		.unpackEncodedString(DFA201_acceptS);
	static final short[] DFA201_special = DFA
		.unpackEncodedString(DFA201_specialS);
	static final short[][] DFA201_transition;

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

	class DFA201 extends DFA {

		public DFA201(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 201;
			this.eot = DFA201_eot;
			this.eof = DFA201_eof;
			this.min = DFA201_min;
			this.max = DFA201_max;
			this.accept = DFA201_accept;
			this.special = DFA201_special;
			this.transition = DFA201_transition;
		}
		public String getDescription() {
			return "2090:1: overloadablebinaryoperator returns [String content] : ( pLUS | mUL | dIV | mOD | aMPERSAND | bITWISEOR | bITWISEXOR | lEFTSHIFT | rIGHTSHIFT | eQUALS | nOTEQUALS | gT | lT | gE | lE );";
		}
	}
	static final String DFA212_eotS = "\5\uffff";
	static final String DFA212_eofS = "\5\uffff";
	static final String DFA212_minS = "\1\u00ba\2\u00ad\2\uffff";
	static final String DFA212_maxS = "\1\u00ba\2\u011c\2\uffff";
	static final String DFA212_acceptS = "\3\uffff\1\1\1\2";
	static final String DFA212_specialS = "\5\uffff}>";
	static final String[] DFA212_transitionS = { "\1\1",
			"\5\2\56\uffff\1\3\73\uffff\1\4", "\5\2\56\uffff\1\3\73\uffff\1\4",
			"", "" };

	static final short[] DFA212_eot = DFA.unpackEncodedString(DFA212_eotS);
	static final short[] DFA212_eof = DFA.unpackEncodedString(DFA212_eofS);
	static final char[] DFA212_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA212_minS);
	static final char[] DFA212_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA212_maxS);
	static final short[] DFA212_accept = DFA
		.unpackEncodedString(DFA212_acceptS);
	static final short[] DFA212_special = DFA
		.unpackEncodedString(DFA212_specialS);
	static final short[][] DFA212_transition;

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

	class DFA212 extends DFA {

		public DFA212(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 212;
			this.eot = DFA212_eot;
			this.eof = DFA212_eof;
			this.min = DFA212_min;
			this.max = DFA212_max;
			this.accept = DFA212_accept;
			this.special = DFA212_special;
			this.transition = DFA212_transition;
		}
		public String getDescription() {
			return "2157:1: constructorinitializer : ( cOLON bASE lPAREN ( argumentlist )? rPAREN -> ^( BaseInitializer cOLON bASE lPAREN ( argumentlist )? rPAREN ) | cOLON tHIS lPAREN ( argumentlist )? rPAREN -> ^( ThisInitializer cOLON tHIS lPAREN ( argumentlist )? rPAREN ) );";
		}
	}
	static final String DFA232_eotS = "\64\uffff";
	static final String DFA232_eofS = "\64\uffff";
	static final String DFA232_minS =
		"\1\u00b4\6\0\1\uffff\1\0\2\uffff\35\0\14\uffff";
	static final String DFA232_maxS =
		"\1\u0133\6\0\1\uffff\1\0\2\uffff\35\0\14\uffff";
	static final String DFA232_acceptS =
		"\7\uffff\1\1\1\uffff\1\2\36\uffff\1\3\1\5\1\12\4\uffff\1\4\1\6"
				+ "\1\7\1\10\1\11";
	static final String DFA232_specialS =
		"\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\uffff\1\7\2\uffff\1\10\1\11\1\12"
				+ "\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27"
				+ "\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\1\40\1\41\1\42\1\43\1\44"
				+ "\14\uffff}>";
	static final String[] DFA232_transitionS =
		{
				"\1\1\51\uffff\1\46\2\uffff\1\40\1\uffff\1\25\2\uffff\1\34\1"
						+ "\uffff\1\52\1\7\1\uffff\1\37\1\uffff\1\52\1\uffff\1\36\1\uffff"
						+ "\1\52\1\51\1\uffff\1\47\3\uffff\1\35\6\uffff\1\30\1\52\1\5\2"
						+ "\uffff\1\32\1\uffff\1\2\1\uffff\1\41\2\uffff\1\45\1\uffff\1"
						+ "\6\1\4\1\3\1\11\2\uffff\1\24\1\44\1\26\2\uffff\1\10\1\42\1\52"
						+ "\6\uffff\1\31\1\33\2\uffff\1\27\1\uffff\1\43\1\50\1\11\1\uffff"
						+ "\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\13",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "", "\1\uffff", "", "", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "", "", "", "", "", "", "", "", "", "",
				"", "" };

	static final short[] DFA232_eot = DFA.unpackEncodedString(DFA232_eotS);
	static final short[] DFA232_eof = DFA.unpackEncodedString(DFA232_eofS);
	static final char[] DFA232_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA232_minS);
	static final char[] DFA232_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA232_maxS);
	static final short[] DFA232_accept = DFA
		.unpackEncodedString(DFA232_acceptS);
	static final short[] DFA232_special = DFA
		.unpackEncodedString(DFA232_specialS);
	static final short[][] DFA232_transition;

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

	class DFA232 extends DFA {

		public DFA232(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 232;
			this.eot = DFA232_eot;
			this.eof = DFA232_eof;
			this.min = DFA232_min;
			this.max = DFA232_max;
			this.accept = DFA232_accept;
			this.special = DFA232_special;
			this.transition = DFA232_transition;
		}
		public String getDescription() {
			return "2243:1: structmemberdeclaration : ( ( ( attributes )? ( constantmodifiers )? cONST )=> constantdeclaration -> ^( StructMemberDeclaration constantdeclaration ) | fielddeclaration -> ^( StructMemberDeclaration fielddeclaration ) | ( methodheader )=> methoddeclaration -> ^( StructMemberDeclaration methoddeclaration ) | propertydeclaration -> ^( StructMemberDeclaration propertydeclaration ) | ( ( attributes )? ( eventmodifiers )? eVENT )=> eventdeclaration -> ^( StructMemberDeclaration eventdeclaration ) | ( ( attributes )? ( indexermodifiers )? indexerdeclarator )=> indexerdeclaration -> ^( StructMemberDeclaration indexerdeclaration ) | ( ( attributes )? operatormodifiers operatordeclarator )=> operatordeclaration -> ^( StructMemberDeclaration operatordeclaration ) | ( ( attributes )? ( constructormodifiers )? constructordeclarator )=> constructordeclaration -> ^( StructMemberDeclaration constructordeclaration ) | ( ( attributes )? staticconstructormodifiers identifier lPAREN rPAREN )=> staticconstructordeclaration -> ^( StructMemberDeclaration staticconstructordeclaration ) | typedeclaration -> ^( StructMemberDeclaration typedeclaration ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					int LA232_0 = input.LA(1);

					int index232_0 = input.index();
					input.rewind();
					s = -1;
					if ((LA232_0 == LBRACKET)) {
						s = 1;
					}

					else if ((LA232_0 == NEW)) {
						s = 2;
					}

					else if ((LA232_0 == PUBLIC)) {
						s = 3;
					}

					else if ((LA232_0 == PROTECTED)) {
						s = 4;
					}

					else if ((LA232_0 == INTERNAL)) {
						s = 5;
					}

					else if ((LA232_0 == PRIVATE)) {
						s = 6;
					}

					else if ((LA232_0 == CONST) && (synpred542_CSharp())) {
						s = 7;
					}

					else if ((LA232_0 == STATIC)) {
						s = 8;
					}

					else if ((LA232_0 == READONLY || LA232_0 == VOLATILE)) {
						s = 9;
					}

					else if ((LA232_0 == Ident)) {
						s = 11;
					}

					else if ((LA232_0 == ADD)) {
						s = 12;
					}

					else if ((LA232_0 == ALIAS)) {
						s = 13;
					}

					else if ((LA232_0 == GET)) {
						s = 14;
					}

					else if ((LA232_0 == PARTIAL)) {
						s = 15;
					}

					else if ((LA232_0 == REMOVE)) {
						s = 16;
					}

					else if ((LA232_0 == SET)) {
						s = 17;
					}

					else if ((LA232_0 == WHERE)) {
						s = 18;
					}

					else if ((LA232_0 == YIELD)) {
						s = 19;
					}

					else if ((LA232_0 == SBYTE)) {
						s = 20;
					}

					else if ((LA232_0 == BYTE)) {
						s = 21;
					}

					else if ((LA232_0 == SHORT)) {
						s = 22;
					}

					else if ((LA232_0 == USHORT)) {
						s = 23;
					}

					else if ((LA232_0 == INT)) {
						s = 24;
					}

					else if ((LA232_0 == UINT)) {
						s = 25;
					}

					else if ((LA232_0 == LONG)) {
						s = 26;
					}

					else if ((LA232_0 == ULONG)) {
						s = 27;
					}

					else if ((LA232_0 == CHAR)) {
						s = 28;
					}

					else if ((LA232_0 == FLOAT)) {
						s = 29;
					}

					else if ((LA232_0 == DOUBLE)) {
						s = 30;
					}

					else if ((LA232_0 == DECIMAL)) {
						s = 31;
					}

					else if ((LA232_0 == BOOL)) {
						s = 32;
					}

					else if ((LA232_0 == OBJECT)) {
						s = 33;
					}

					else if ((LA232_0 == STRING)) {
						s = 34;
					}

					else if ((LA232_0 == VIRTUAL)) {
						s = 35;
					}

					else if ((LA232_0 == SEALED)) {
						s = 36;
					}

					else if ((LA232_0 == OVERRIDE)) {
						s = 37;
					}

					else if ((LA232_0 == ABSTRACT)) {
						s = 38;
					}

					else if ((LA232_0 == EXTERN)) {
						s = 39;
					}

					else if ((LA232_0 == VOID) && (synpred544_CSharp())) {
						s = 40;
					}

					else if ((LA232_0 == EVENT) && (synpred548_CSharp())) {
						s = 41;
					}

					else if ((LA232_0 == CLASS || LA232_0 == DELEGATE
							|| LA232_0 == ENUM || LA232_0 == INTERFACE || LA232_0 == STRUCT)) {
						s = 42;
					}

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

					int index232_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred542_CSharp())) {
						s = 7;
					}

					else if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred553_CSharp())) {
						s = 49;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					else if ((synpred558_CSharp())) {
						s = 51;
					}

					else if ((true)) {
						s = 42;
					}

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

					int index232_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred542_CSharp())) {
						s = 7;
					}

					else if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((true)) {
						s = 42;
					}

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

					int index232_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred542_CSharp())) {
						s = 7;
					}

					else if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred553_CSharp())) {
						s = 49;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					else if ((true)) {
						s = 42;
					}

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

					int index232_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred542_CSharp())) {
						s = 7;
					}

					else if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					else if ((true)) {
						s = 42;
					}

					input.seek(index232_4);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index232_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred542_CSharp())) {
						s = 7;
					}

					else if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					else if ((true)) {
						s = 42;
					}

					input.seek(index232_5);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index232_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred542_CSharp())) {
						s = 7;
					}

					else if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					else if ((true)) {
						s = 42;
					}

					input.seek(index232_6);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index232_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred553_CSharp())) {
						s = 49;
					}

					else if ((synpred558_CSharp())) {
						s = 51;
					}

					else if ((true)) {
						s = 42;
					}

					input.seek(index232_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index232_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					input.seek(index232_11);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index232_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					input.seek(index232_12);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index232_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					input.seek(index232_13);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index232_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					input.seek(index232_14);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index232_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					else if ((true)) {
						s = 42;
					}

					input.seek(index232_15);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index232_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					input.seek(index232_16);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index232_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					input.seek(index232_17);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index232_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					input.seek(index232_18);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index232_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					input.seek(index232_19);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index232_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_20);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index232_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_21);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index232_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_22);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index232_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_23);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index232_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_24);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index232_25 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_25);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index232_26 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_26);
					if (s >= 0)
						return s;
					break;
				case 24 :
					input.LA(1);

					int index232_27 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_27);
					if (s >= 0)
						return s;
					break;
				case 25 :
					input.LA(1);

					int index232_28 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_28);
					if (s >= 0)
						return s;
					break;
				case 26 :
					input.LA(1);

					int index232_29 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_29);
					if (s >= 0)
						return s;
					break;
				case 27 :
					input.LA(1);

					int index232_30 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_30);
					if (s >= 0)
						return s;
					break;
				case 28 :
					input.LA(1);

					int index232_31 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_31);
					if (s >= 0)
						return s;
					break;
				case 29 :
					input.LA(1);

					int index232_32 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_32);
					if (s >= 0)
						return s;
					break;
				case 30 :
					input.LA(1);

					int index232_33 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_33);
					if (s >= 0)
						return s;
					break;
				case 31 :
					input.LA(1);

					int index232_34 = input.index();
					input.rewind();
					s = -1;
					if ((synpred543_CSharp())) {
						s = 9;
					}

					else if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_34);
					if (s >= 0)
						return s;
					break;
				case 32 :
					input.LA(1);

					int index232_35 = input.index();
					input.rewind();
					s = -1;
					if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_35);
					if (s >= 0)
						return s;
					break;
				case 33 :
					input.LA(1);

					int index232_36 = input.index();
					input.rewind();
					s = -1;
					if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((true)) {
						s = 42;
					}

					input.seek(index232_36);
					if (s >= 0)
						return s;
					break;
				case 34 :
					input.LA(1);

					int index232_37 = input.index();
					input.rewind();
					s = -1;
					if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					input.seek(index232_37);
					if (s >= 0)
						return s;
					break;
				case 35 :
					input.LA(1);

					int index232_38 = input.index();
					input.rewind();
					s = -1;
					if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((true)) {
						s = 42;
					}

					input.seek(index232_38);
					if (s >= 0)
						return s;
					break;
				case 36 :
					input.LA(1);

					int index232_39 = input.index();
					input.rewind();
					s = -1;
					if ((synpred544_CSharp())) {
						s = 40;
					}

					else if ((synpred545_CSharp())) {
						s = 47;
					}

					else if ((synpred548_CSharp())) {
						s = 41;
					}

					else if ((synpred551_CSharp())) {
						s = 48;
					}

					else if ((synpred553_CSharp())) {
						s = 49;
					}

					else if ((synpred556_CSharp())) {
						s = 50;
					}

					else if ((synpred558_CSharp())) {
						s = 51;
					}

					input.seek(index232_39);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 232, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA233_eotS = "\17\uffff";
	static final String DFA233_eofS = "\17\uffff";
	static final String DFA233_minS = "\1\u00e1\11\0\5\uffff";
	static final String DFA233_maxS = "\1\u0133\11\0\5\uffff";
	static final String DFA233_acceptS = "\12\uffff\1\1\1\2\1\3\1\4\1\5";
	static final String DFA233_specialS =
		"\1\uffff\1\0\1\5\1\6\1\2\1\4\1\7\1\10\1\1\1\3\5\uffff}>";
	static final String[] DFA233_transitionS =
		{
				"\1\12\1\uffff\1\12\2\uffff\1\12\4\uffff\1\12\3\uffff\1\12\10"
						+ "\uffff\1\12\6\uffff\1\12\4\uffff\1\12\3\uffff\1\13\12\uffff"
						+ "\1\12\1\uffff\1\12\3\uffff\1\13\7\uffff\2\12\2\uffff\1\12\5"
						+ "\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "", "", "", "",
				"" };

	static final short[] DFA233_eot = DFA.unpackEncodedString(DFA233_eotS);
	static final short[] DFA233_eof = DFA.unpackEncodedString(DFA233_eofS);
	static final char[] DFA233_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA233_minS);
	static final char[] DFA233_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA233_maxS);
	static final short[] DFA233_accept = DFA
		.unpackEncodedString(DFA233_acceptS);
	static final short[] DFA233_special = DFA
		.unpackEncodedString(DFA233_specialS);
	static final short[][] DFA233_transition;

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

	class DFA233 extends DFA {

		public DFA233(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 233;
			this.eot = DFA233_eot;
			this.eof = DFA233_eof;
			this.min = DFA233_min;
			this.max = DFA233_max;
			this.accept = DFA233_accept;
			this.special = DFA233_special;
			this.transition = DFA233_transition;
		}
		public String getDescription() {
			return "2273:1: nonarraytype returns [String name] : ( valuetype | classtype | interfacetype | delegatetype | typeparameter );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index233_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

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

					int index233_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

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

					int index233_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

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

					int index233_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

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

					int index233_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

					input.seek(index233_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index233_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

					input.seek(index233_2);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index233_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

					input.seek(index233_3);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index233_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

					input.seek(index233_6);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index233_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred559_CSharp())) {
						s = 10;
					}

					else if ((synpred560_CSharp())) {
						s = 11;
					}

					else if ((synpred561_CSharp())) {
						s = 12;
					}

					else if ((synpred562_CSharp())) {
						s = 13;
					}

					else if ((true)) {
						s = 14;
					}

					input.seek(index233_7);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 233, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA234_eotS = "\5\uffff";
	static final String DFA234_eofS = "\1\1\4\uffff";
	static final String DFA234_minS = "\1\u00b2\1\uffff\2\u00ad\1\uffff";
	static final String DFA234_maxS = "\1\u0133\1\uffff\2\u0137\1\uffff";
	static final String DFA234_acceptS = "\1\uffff\1\2\2\uffff\1\1";
	static final String DFA234_specialS = "\5\uffff}>";
	static final String[] DFA234_transitionS =
		{
				"\2\1\1\2\17\1\2\uffff\4\1\1\uffff\4\1\1\uffff\16\1\1\uffff"
						+ "\1\1\42\uffff\1\1\6\uffff\1\1\22\uffff\1\1\16\uffff\11\1",
				"",
				"\5\3\3\uffff\1\4\1\1\2\uffff\1\4\2\uffff\2\1\6\uffff\2\1\5"
						+ "\uffff\2\1\23\uffff\2\1\1\uffff\1\1\2\uffff\2\1\3\uffff\3\1"
						+ "\1\uffff\1\1\5\uffff\1\1\2\uffff\1\1\6\uffff\1\1\4\uffff\1\1"
						+ "\1\uffff\3\1\12\uffff\1\1\1\uffff\1\1\3\uffff\1\1\2\uffff\1"
						+ "\1\1\uffff\1\1\1\uffff\4\1\1\uffff\1\1\5\uffff\15\1",
				"\5\3\3\uffff\1\4\1\1\2\uffff\1\4\2\uffff\2\1\6\uffff\2\1\5"
						+ "\uffff\2\1\23\uffff\2\1\1\uffff\1\1\2\uffff\2\1\3\uffff\3\1"
						+ "\1\uffff\1\1\5\uffff\1\1\2\uffff\1\1\6\uffff\1\1\4\uffff\1\1"
						+ "\1\uffff\3\1\12\uffff\1\1\1\uffff\1\1\3\uffff\1\1\2\uffff\1"
						+ "\1\1\uffff\1\1\1\uffff\4\1\1\uffff\1\1\5\uffff\15\1",
				"" };

	static final short[] DFA234_eot = DFA.unpackEncodedString(DFA234_eotS);
	static final short[] DFA234_eof = DFA.unpackEncodedString(DFA234_eofS);
	static final char[] DFA234_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA234_minS);
	static final char[] DFA234_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA234_maxS);
	static final short[] DFA234_accept = DFA
		.unpackEncodedString(DFA234_acceptS);
	static final short[] DFA234_special = DFA
		.unpackEncodedString(DFA234_specialS);
	static final short[][] DFA234_transition;

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

	class DFA234 extends DFA {

		public DFA234(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 234;
			this.eot = DFA234_eot;
			this.eof = DFA234_eof;
			this.min = DFA234_min;
			this.max = DFA234_max;
			this.accept = DFA234_accept;
			this.special = DFA234_special;
			this.transition = DFA234_transition;
		}
		public String getDescription() {
			return "()+ loopback of 2290:9: ( rankspecifier )+";
		}
	}
	static final String DFA239_eotS = "\5\uffff";
	static final String DFA239_eofS = "\1\1\4\uffff";
	static final String DFA239_minS = "\1\u00b3\1\uffff\2\u00ad\1\uffff";
	static final String DFA239_maxS = "\1\u00b9\1\uffff\2\u0137\1\uffff";
	static final String DFA239_acceptS = "\1\uffff\1\2\2\uffff\1\1";
	static final String DFA239_specialS = "\5\uffff}>";
	static final String[] DFA239_transitionS =
		{
				"\1\1\5\uffff\1\2",
				"",
				"\5\3\1\4\1\1\2\uffff\1\4\5\uffff\2\4\6\uffff\2\4\5\uffff\2"
						+ "\4\23\uffff\2\4\1\uffff\1\4\2\uffff\2\4\3\uffff\3\4\1\uffff"
						+ "\1\4\5\uffff\1\4\2\uffff\1\4\6\uffff\1\4\4\uffff\1\4\1\uffff"
						+ "\3\4\12\uffff\1\4\1\uffff\1\4\3\uffff\1\4\2\uffff\1\4\1\uffff"
						+ "\1\4\1\uffff\4\4\1\uffff\1\4\5\uffff\15\4",
				"\5\3\1\4\1\1\2\uffff\1\4\5\uffff\2\4\6\uffff\2\4\5\uffff\2"
						+ "\4\23\uffff\2\4\1\uffff\1\4\2\uffff\2\4\3\uffff\3\4\1\uffff"
						+ "\1\4\5\uffff\1\4\2\uffff\1\4\6\uffff\1\4\4\uffff\1\4\1\uffff"
						+ "\3\4\12\uffff\1\4\1\uffff\1\4\3\uffff\1\4\2\uffff\1\4\1\uffff"
						+ "\1\4\1\uffff\4\4\1\uffff\1\4\5\uffff\15\4", "" };

	static final short[] DFA239_eot = DFA.unpackEncodedString(DFA239_eotS);
	static final short[] DFA239_eof = DFA.unpackEncodedString(DFA239_eofS);
	static final char[] DFA239_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA239_minS);
	static final char[] DFA239_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA239_maxS);
	static final short[] DFA239_accept = DFA
		.unpackEncodedString(DFA239_acceptS);
	static final short[] DFA239_special = DFA
		.unpackEncodedString(DFA239_specialS);
	static final short[][] DFA239_transition;

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

	class DFA239 extends DFA {

		public DFA239(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 239;
			this.eot = DFA239_eot;
			this.eof = DFA239_eof;
			this.min = DFA239_min;
			this.max = DFA239_max;
			this.accept = DFA239_accept;
			this.special = DFA239_special;
			this.transition = DFA239_transition;
		}
		public String getDescription() {
			return "()* loopback of 2320:29: ( cOMMA variableinitializer )*";
		}
	}
	static final String DFA251_eotS = "\37\uffff";
	static final String DFA251_eofS = "\37\uffff";
	static final String DFA251_minS = "\1\u00b4\32\0\4\uffff";
	static final String DFA251_maxS = "\1\u0133\32\0\4\uffff";
	static final String DFA251_acceptS = "\33\uffff\1\1\1\3\1\2\1\4";
	static final String DFA251_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30"
				+ "\1\31\4\uffff}>";
	static final String[] DFA251_transitionS =
		{
				"\1\1\54\uffff\1\30\1\uffff\1\15\2\uffff\1\24\4\uffff\1\27\3"
						+ "\uffff\1\26\2\uffff\1\34\5\uffff\1\25\6\uffff\1\20\4\uffff\1"
						+ "\22\1\uffff\1\2\1\uffff\1\31\12\uffff\1\14\1\uffff\1\16\3\uffff"
						+ "\1\32\7\uffff\1\21\1\23\2\uffff\1\17\2\uffff\1\33\2\uffff\1"
						+ "\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\3", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "",
				"", "", "" };

	static final short[] DFA251_eot = DFA.unpackEncodedString(DFA251_eotS);
	static final short[] DFA251_eof = DFA.unpackEncodedString(DFA251_eofS);
	static final char[] DFA251_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA251_minS);
	static final char[] DFA251_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA251_maxS);
	static final short[] DFA251_accept = DFA
		.unpackEncodedString(DFA251_acceptS);
	static final short[] DFA251_special = DFA
		.unpackEncodedString(DFA251_specialS);
	static final short[][] DFA251_transition;

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

	class DFA251 extends DFA {

		public DFA251(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 251;
			this.eot = DFA251_eot;
			this.eof = DFA251_eof;
			this.min = DFA251_min;
			this.max = DFA251_max;
			this.accept = DFA251_accept;
			this.special = DFA251_special;
			this.transition = DFA251_transition;
		}
		public String getDescription() {
			return "2387:1: interfacememberdeclaration : ( interfacemethoddeclaration -> ^( InterfaceMemberDeclaration interfacemethoddeclaration ) | interfacepropertydeclaration -> ^( InterfaceMemberDeclaration interfacepropertydeclaration ) | interfaceeventdeclaration -> ^( InterfaceMemberDeclaration interfaceeventdeclaration ) | interfaceindexerdeclaration -> ^( InterfaceMemberDeclaration interfaceindexerdeclaration ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index251_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((synpred585_CSharp())) {
						s = 28;
					}

					else if ((true)) {
						s = 30;
					}

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

					int index251_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((synpred585_CSharp())) {
						s = 28;
					}

					else if ((true)) {
						s = 30;
					}

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

					int index251_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

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

					int index251_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

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

					int index251_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index251_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index251_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index251_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index251_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index251_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index251_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index251_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index251_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_13);
					if (s >= 0)
						return s;
					break;
				case 13 :
					input.LA(1);

					int index251_14 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_14);
					if (s >= 0)
						return s;
					break;
				case 14 :
					input.LA(1);

					int index251_15 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_15);
					if (s >= 0)
						return s;
					break;
				case 15 :
					input.LA(1);

					int index251_16 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_16);
					if (s >= 0)
						return s;
					break;
				case 16 :
					input.LA(1);

					int index251_17 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_17);
					if (s >= 0)
						return s;
					break;
				case 17 :
					input.LA(1);

					int index251_18 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_18);
					if (s >= 0)
						return s;
					break;
				case 18 :
					input.LA(1);

					int index251_19 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_19);
					if (s >= 0)
						return s;
					break;
				case 19 :
					input.LA(1);

					int index251_20 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_20);
					if (s >= 0)
						return s;
					break;
				case 20 :
					input.LA(1);

					int index251_21 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_21);
					if (s >= 0)
						return s;
					break;
				case 21 :
					input.LA(1);

					int index251_22 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_22);
					if (s >= 0)
						return s;
					break;
				case 22 :
					input.LA(1);

					int index251_23 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_23);
					if (s >= 0)
						return s;
					break;
				case 23 :
					input.LA(1);

					int index251_24 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_24);
					if (s >= 0)
						return s;
					break;
				case 24 :
					input.LA(1);

					int index251_25 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_25);
					if (s >= 0)
						return s;
					break;
				case 25 :
					input.LA(1);

					int index251_26 = input.index();
					input.rewind();
					s = -1;
					if ((synpred583_CSharp())) {
						s = 27;
					}

					else if ((synpred584_CSharp())) {
						s = 29;
					}

					else if ((true)) {
						s = 30;
					}

					input.seek(index251_26);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 251, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA278_eotS = "\5\uffff";
	static final String DFA278_eofS = "\1\1\4\uffff";
	static final String DFA278_minS = "\1\u00b3\1\uffff\2\u00ad\1\uffff";
	static final String DFA278_maxS = "\1\u00b9\1\uffff\2\u0133\1\uffff";
	static final String DFA278_acceptS = "\1\uffff\1\2\2\uffff\1\1";
	static final String DFA278_specialS = "\5\uffff}>";
	static final String[] DFA278_transitionS = { "\1\1\5\uffff\1\2", "",
			"\5\3\1\uffff\1\1\1\4\166\uffff\11\4",
			"\5\3\1\uffff\1\1\1\4\166\uffff\11\4", "" };

	static final short[] DFA278_eot = DFA.unpackEncodedString(DFA278_eotS);
	static final short[] DFA278_eof = DFA.unpackEncodedString(DFA278_eofS);
	static final char[] DFA278_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA278_minS);
	static final char[] DFA278_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA278_maxS);
	static final short[] DFA278_accept = DFA
		.unpackEncodedString(DFA278_acceptS);
	static final short[] DFA278_special = DFA
		.unpackEncodedString(DFA278_specialS);
	static final short[][] DFA278_transition;

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

	class DFA278 extends DFA {

		public DFA278(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 278;
			this.eot = DFA278_eot;
			this.eof = DFA278_eof;
			this.min = DFA278_min;
			this.max = DFA278_max;
			this.accept = DFA278_accept;
			this.special = DFA278_special;
			this.transition = DFA278_transition;
		}
		public String getDescription() {
			return "()* loopback of 2489:31: ( cOMMA enummemberdeclaration )*";
		}
	}
	static final String DFA281_eotS = "\15\uffff";
	static final String DFA281_eofS = "\15\uffff";
	static final String DFA281_minS = "\1\u00b4\12\0\2\uffff";
	static final String DFA281_maxS = "\1\u0133\12\0\2\uffff";
	static final String DFA281_acceptS = "\13\uffff\1\1\1\2";
	static final String DFA281_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\2\uffff}>";
	static final String[] DFA281_transitionS =
		{ "\1\1\166\uffff\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\2", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
				"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "", "" };

	static final short[] DFA281_eot = DFA.unpackEncodedString(DFA281_eotS);
	static final short[] DFA281_eof = DFA.unpackEncodedString(DFA281_eofS);
	static final char[] DFA281_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA281_minS);
	static final char[] DFA281_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA281_maxS);
	static final short[] DFA281_accept = DFA
		.unpackEncodedString(DFA281_acceptS);
	static final short[] DFA281_special = DFA
		.unpackEncodedString(DFA281_specialS);
	static final short[][] DFA281_transition;

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

	class DFA281 extends DFA {

		public DFA281(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 281;
			this.eot = DFA281_eot;
			this.eof = DFA281_eof;
			this.min = DFA281_min;
			this.max = DFA281_max;
			this.accept = DFA281_accept;
			this.special = DFA281_special;
			this.transition = DFA281_transition;
		}
		public String getDescription() {
			return "2492:1: enummemberdeclaration : ( ( attributes )? identifier aSSIGN constantexpression -> ^( EnumMemberDeclaration ( attributes )? identifier aSSIGN constantexpression ) | ( attributes )? identifier -> ^( EnumMemberDeclaration ( attributes )? identifier ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index281_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

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

					int index281_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

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

					int index281_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

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

					int index281_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

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

					int index281_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

					input.seek(index281_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index281_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

					input.seek(index281_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index281_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

					input.seek(index281_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index281_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

					input.seek(index281_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index281_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

					input.seek(index281_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index281_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred617_CSharp())) {
						s = 11;
					}

					else if ((true)) {
						s = 12;
					}

					input.seek(index281_10);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 281, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA289_eotS = "\23\uffff";
	static final String DFA289_eofS = "\1\1\22\uffff";
	static final String DFA289_minS = "\1\u00b4\1\uffff\1\0\20\uffff";
	static final String DFA289_maxS = "\1\u012e\1\uffff\1\0\20\uffff";
	static final String DFA289_acceptS = "\1\uffff\1\2\20\uffff\1\1";
	static final String DFA289_specialS = "\2\uffff\1\0\20\uffff}>";
	static final String[] DFA289_transitionS =
		{
				"\1\2\51\uffff\1\1\11\uffff\1\1\4\uffff\1\1\3\uffff\1\1\16\uffff"
						+ "\2\1\3\uffff\2\1\6\uffff\3\1\4\uffff\1\1\3\uffff\1\1\1\uffff"
						+ "\1\1\23\uffff\1\1", "", "\1\uffff", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "", "", "" };

	static final short[] DFA289_eot = DFA.unpackEncodedString(DFA289_eotS);
	static final short[] DFA289_eof = DFA.unpackEncodedString(DFA289_eofS);
	static final char[] DFA289_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA289_minS);
	static final char[] DFA289_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA289_maxS);
	static final short[] DFA289_accept = DFA
		.unpackEncodedString(DFA289_acceptS);
	static final short[] DFA289_special = DFA
		.unpackEncodedString(DFA289_specialS);
	static final short[][] DFA289_transition;

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

	class DFA289 extends DFA {

		public DFA289(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 289;
			this.eot = DFA289_eot;
			this.eof = DFA289_eof;
			this.min = DFA289_min;
			this.max = DFA289_max;
			this.accept = DFA289_accept;
			this.special = DFA289_special;
			this.transition = DFA289_transition;
		}
		public String getDescription() {
			return "()+ loopback of 2526:9: ( globalattributesection )+";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index289_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred629_CSharp())) {
						s = 18;
					}

					else if ((true)) {
						s = 1;
					}

					input.seek(index289_2);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 289, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA293_eotS = "\25\uffff";
	static final String DFA293_eofS = "\25\uffff";
	static final String DFA293_minS =
		"\1\u00de\11\u00ad\1\uffff\1\u00ad\1\uffff\10\u00ad";
	static final String DFA293_maxS =
		"\1\u0133\11\u00ca\1\uffff\1\u00ca\1\uffff\10\u00ca";
	static final String DFA293_acceptS = "\12\uffff\1\1\1\uffff\1\2\10\uffff";
	static final String DFA293_specialS = "\25\uffff}>";
	static final String[] DFA293_transitionS = {
			"\115\12\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1",
			"\5\13\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\15\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\16\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\17\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\20\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\21\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\22\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\23\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\24\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"",
			"\5\13\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"",
			"\5\15\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\16\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\17\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\20\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\21\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\22\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\23\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14",
			"\5\24\3\uffff\2\14\1\uffff\2\14\1\12\14\uffff\1\14\2\uffff"
					+ "\1\14" };

	static final short[] DFA293_eot = DFA.unpackEncodedString(DFA293_eotS);
	static final short[] DFA293_eof = DFA.unpackEncodedString(DFA293_eofS);
	static final char[] DFA293_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA293_minS);
	static final char[] DFA293_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA293_maxS);
	static final short[] DFA293_accept = DFA
		.unpackEncodedString(DFA293_acceptS);
	static final short[] DFA293_special = DFA
		.unpackEncodedString(DFA293_specialS);
	static final short[][] DFA293_transition;

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

	class DFA293 extends DFA {

		public DFA293(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 293;
			this.eot = DFA293_eot;
			this.eof = DFA293_eof;
			this.min = DFA293_min;
			this.max = DFA293_max;
			this.accept = DFA293_accept;
			this.special = DFA293_special;
			this.transition = DFA293_transition;
		}
		public String getDescription() {
			return "2559:18: ( attributetargetspecifier )?";
		}
	}
	static final String DFA296_eotS = "\5\uffff";
	static final String DFA296_eofS = "\5\uffff";
	static final String DFA296_minS = "\1\u00b5\1\uffff\2\u00ad\1\uffff";
	static final String DFA296_maxS = "\1\u00b9\1\uffff\2\u0133\1\uffff";
	static final String DFA296_acceptS = "\1\uffff\1\2\2\uffff\1\1";
	static final String DFA296_specialS = "\5\uffff}>";
	static final String[] DFA296_transitionS = { "\1\1\3\uffff\1\2", "",
			"\5\3\3\uffff\1\1\165\uffff\11\4",
			"\5\3\3\uffff\1\1\165\uffff\11\4", "" };

	static final short[] DFA296_eot = DFA.unpackEncodedString(DFA296_eotS);
	static final short[] DFA296_eof = DFA.unpackEncodedString(DFA296_eofS);
	static final char[] DFA296_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA296_minS);
	static final char[] DFA296_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA296_maxS);
	static final short[] DFA296_accept = DFA
		.unpackEncodedString(DFA296_acceptS);
	static final short[] DFA296_special = DFA
		.unpackEncodedString(DFA296_specialS);
	static final short[][] DFA296_transition;

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

	class DFA296 extends DFA {

		public DFA296(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 296;
			this.eot = DFA296_eot;
			this.eof = DFA296_eof;
			this.min = DFA296_min;
			this.max = DFA296_max;
			this.accept = DFA296_accept;
			this.special = DFA296_special;
			this.transition = DFA296_transition;
		}
		public String getDescription() {
			return "()* loopback of 2574:19: ( cOMMA attribute )*";
		}
	}
	static final String DFA306_eotS = "\23\uffff";
	static final String DFA306_eofS = "\23\uffff";
	static final String DFA306_minS = "\1\u00e8\15\0\5\uffff";
	static final String DFA306_maxS = "\1\u0133\15\0\5\uffff";
	static final String DFA306_acceptS = "\16\uffff\1\5\1\1\1\2\1\3\1\4";
	static final String DFA306_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"
				+ "\14\5\uffff}>";
	static final String[] DFA306_transitionS = {
			"\1\14\35\uffff\1\16\1\uffff\1\12\20\uffff\1\13\1\15\20\uffff"
					+ "\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1", "\1\uffff",
			"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "", "", "", "", "" };

	static final short[] DFA306_eot = DFA.unpackEncodedString(DFA306_eotS);
	static final short[] DFA306_eof = DFA.unpackEncodedString(DFA306_eofS);
	static final char[] DFA306_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA306_minS);
	static final char[] DFA306_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA306_maxS);
	static final short[] DFA306_accept = DFA
		.unpackEncodedString(DFA306_acceptS);
	static final short[] DFA306_special = DFA
		.unpackEncodedString(DFA306_specialS);
	static final short[][] DFA306_transition;

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

	class DFA306 extends DFA {

		public DFA306(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 306;
			this.eot = DFA306_eot;
			this.eof = DFA306_eof;
			this.min = DFA306_min;
			this.max = DFA306_max;
			this.accept = DFA306_accept;
			this.special = DFA306_special;
			this.transition = DFA306_transition;
		}
		public String getDescription() {
			return "2671:1: typeparameterconstraints : ( primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint -> ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints cOMMA constructorconstraint ) | primaryconstraint cOMMA secondaryconstraints -> ^( TypeParameterConstraints primaryconstraint cOMMA secondaryconstraints ) | primaryconstraint cOMMA constructorconstraint -> ^( TypeParameterConstraints primaryconstraint cOMMA constructorconstraint ) | primaryconstraint -> ^( TypeParameterConstraints primaryconstraint ) | constructorconstraint -> ^( TypeParameterConstraints constructorconstraint ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index306_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

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

					int index306_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

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

					int index306_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

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

					int index306_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

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

					int index306_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index306_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index306_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index306_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index306_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_9);
					if (s >= 0)
						return s;
					break;
				case 9 :
					input.LA(1);

					int index306_10 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_10);
					if (s >= 0)
						return s;
					break;
				case 10 :
					input.LA(1);

					int index306_11 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_11);
					if (s >= 0)
						return s;
					break;
				case 11 :
					input.LA(1);

					int index306_12 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_12);
					if (s >= 0)
						return s;
					break;
				case 12 :
					input.LA(1);

					int index306_13 = input.index();
					input.rewind();
					s = -1;
					if ((synpred647_CSharp())) {
						s = 15;
					}

					else if ((synpred648_CSharp())) {
						s = 16;
					}

					else if ((synpred649_CSharp())) {
						s = 17;
					}

					else if ((synpred650_CSharp())) {
						s = 18;
					}

					input.seek(index306_13);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 306, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA308_eotS = "\14\uffff";
	static final String DFA308_eofS = "\14\uffff";
	static final String DFA308_minS = "\1\u012b\11\0\2\uffff";
	static final String DFA308_maxS = "\1\u0133\11\0\2\uffff";
	static final String DFA308_acceptS = "\12\uffff\1\1\1\2";
	static final String DFA308_specialS =
		"\1\uffff\1\1\1\4\1\6\1\0\1\2\1\3\1\5\1\10\1\7\2\uffff}>";
	static final String[] DFA308_transitionS = {
			"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "", "" };

	static final short[] DFA308_eot = DFA.unpackEncodedString(DFA308_eotS);
	static final short[] DFA308_eof = DFA.unpackEncodedString(DFA308_eofS);
	static final char[] DFA308_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA308_minS);
	static final char[] DFA308_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA308_maxS);
	static final short[] DFA308_accept = DFA
		.unpackEncodedString(DFA308_acceptS);
	static final short[] DFA308_special = DFA
		.unpackEncodedString(DFA308_specialS);
	static final short[][] DFA308_transition;

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

	class DFA308 extends DFA {

		public DFA308(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 308;
			this.eot = DFA308_eot;
			this.eof = DFA308_eof;
			this.min = DFA308_min;
			this.max = DFA308_max;
			this.accept = DFA308_accept;
			this.special = DFA308_special;
			this.transition = DFA308_transition;
		}
		public String getDescription() {
			return "2697:1: secondaryconstraints : ( interfacetype secondaryconstraintsrest -> ^( SecondaryConstraints interfacetype secondaryconstraintsrest ) | typeparameter secondaryconstraintsrest -> ^( SecondaryConstraints typeparameter secondaryconstraintsrest ) );";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index308_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index308_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index308_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index308_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index308_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index308_2);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index308_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index308_7);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index308_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index308_3);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index308_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index308_9);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index308_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred653_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index308_8);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 308, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA310_eotS = "\5\uffff";
	static final String DFA310_eofS = "\1\2\4\uffff";
	static final String DFA310_minS =
		"\1\u00b2\1\u00ad\1\uffff\1\u00ad\1\uffff";
	static final String DFA310_maxS =
		"\1\u0131\1\u0133\1\uffff\1\u0133\1\uffff";
	static final String DFA310_acceptS = "\2\uffff\1\2\1\uffff\1\1";
	static final String DFA310_specialS = "\5\uffff}>";
	static final String[] DFA310_transitionS = {
			"\1\2\6\uffff\1\1\1\uffff\1\2\165\uffff\1\2",
			"\5\3\124\uffff\1\2\44\uffff\11\4", "",
			"\5\3\124\uffff\1\2\44\uffff\11\4", "" };

	static final short[] DFA310_eot = DFA.unpackEncodedString(DFA310_eotS);
	static final short[] DFA310_eof = DFA.unpackEncodedString(DFA310_eofS);
	static final char[] DFA310_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA310_minS);
	static final char[] DFA310_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA310_maxS);
	static final short[] DFA310_accept = DFA
		.unpackEncodedString(DFA310_acceptS);
	static final short[] DFA310_special = DFA
		.unpackEncodedString(DFA310_specialS);
	static final short[][] DFA310_transition;

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

	class DFA310 extends DFA {

		public DFA310(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 310;
			this.eot = DFA310_eot;
			this.eof = DFA310_eof;
			this.min = DFA310_min;
			this.max = DFA310_max;
			this.accept = DFA310_accept;
			this.special = DFA310_special;
			this.transition = DFA310_transition;
		}
		public String getDescription() {
			return "()* loopback of 2705:4: ( cOMMA ( interfacetype | typeparameter ) )*";
		}
	}
	static final String DFA309_eotS = "\14\uffff";
	static final String DFA309_eofS = "\14\uffff";
	static final String DFA309_minS = "\1\u012b\11\0\2\uffff";
	static final String DFA309_maxS = "\1\u0133\11\0\2\uffff";
	static final String DFA309_acceptS = "\12\uffff\1\1\1\2";
	static final String DFA309_specialS =
		"\1\uffff\1\4\1\10\1\1\1\2\1\7\1\0\1\3\1\6\1\5\2\uffff}>";
	static final String[] DFA309_transitionS = {
			"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "", "" };

	static final short[] DFA309_eot = DFA.unpackEncodedString(DFA309_eotS);
	static final short[] DFA309_eof = DFA.unpackEncodedString(DFA309_eofS);
	static final char[] DFA309_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA309_minS);
	static final char[] DFA309_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA309_maxS);
	static final short[] DFA309_accept = DFA
		.unpackEncodedString(DFA309_acceptS);
	static final short[] DFA309_special = DFA
		.unpackEncodedString(DFA309_specialS);
	static final short[][] DFA309_transition;

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

	class DFA309 extends DFA {

		public DFA309(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 309;
			this.eot = DFA309_eot;
			this.eof = DFA309_eof;
			this.min = DFA309_min;
			this.max = DFA309_max;
			this.accept = DFA309_accept;
			this.special = DFA309_special;
			this.transition = DFA309_transition;
		}
		public String getDescription() {
			return "2705:11: ( interfacetype | typeparameter )";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index309_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index309_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index309_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index309_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index309_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index309_1);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index309_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index309_9);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index309_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index309_8);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index309_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index309_5);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index309_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred654_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index309_2);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 309, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA451_eotS = "\14\uffff";
	static final String DFA451_eofS = "\14\uffff";
	static final String DFA451_minS = "\1\u012b\11\0\2\uffff";
	static final String DFA451_maxS = "\1\u0133\11\0\2\uffff";
	static final String DFA451_acceptS = "\12\uffff\1\1\1\2";
	static final String DFA451_specialS =
		"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff}>";
	static final String[] DFA451_transitionS = {
			"\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\1", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff", "\1\uffff",
			"\1\uffff", "\1\uffff", "", "" };

	static final short[] DFA451_eot = DFA.unpackEncodedString(DFA451_eotS);
	static final short[] DFA451_eof = DFA.unpackEncodedString(DFA451_eofS);
	static final char[] DFA451_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA451_minS);
	static final char[] DFA451_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA451_maxS);
	static final short[] DFA451_accept = DFA
		.unpackEncodedString(DFA451_acceptS);
	static final short[] DFA451_special = DFA
		.unpackEncodedString(DFA451_specialS);
	static final short[][] DFA451_transition;

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

	class DFA451 extends DFA {

		public DFA451(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 451;
			this.eot = DFA451_eot;
			this.eof = DFA451_eof;
			this.min = DFA451_min;
			this.max = DFA451_max;
			this.accept = DFA451_accept;
			this.special = DFA451_special;
			this.transition = DFA451_transition;
		}
		public String getDescription() {
			return "()+ loopback of 391:4: ( simplenamespaceortypename dOT )+";
		}
		public int specialStateTransition(int s, IntStream _input)
				throws NoViableAltException {
			TokenStream input = (TokenStream) _input;
			int _s = s;
			switch (s) {
				case 0 :
					input.LA(1);

					int index451_1 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index451_2 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index451_3 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index451_4 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

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

					int index451_5 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index451_5);
					if (s >= 0)
						return s;
					break;
				case 5 :
					input.LA(1);

					int index451_6 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index451_6);
					if (s >= 0)
						return s;
					break;
				case 6 :
					input.LA(1);

					int index451_7 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index451_7);
					if (s >= 0)
						return s;
					break;
				case 7 :
					input.LA(1);

					int index451_8 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index451_8);
					if (s >= 0)
						return s;
					break;
				case 8 :
					input.LA(1);

					int index451_9 = input.index();
					input.rewind();
					s = -1;
					if ((synpred90_CSharp())) {
						s = 10;
					}

					else if ((true)) {
						s = 11;
					}

					input.seek(index451_9);
					if (s >= 0)
						return s;
					break;
			}
			if (CSharpParser.this.state.backtracking > 0) {
				CSharpParser.this.state.failed = true;
				return -1;
			}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 451, _s, input);
			error(nvae);
			throw nvae;
		}
	}
	static final String DFA468_eotS = "\5\uffff";
	static final String DFA468_eofS = "\5\uffff";
	static final String DFA468_minS = "\1\u00e5\2\u00ad\2\uffff";
	static final String DFA468_maxS = "\1\u00e5\2\u00b6\2\uffff";
	static final String DFA468_acceptS = "\3\uffff\1\1\1\2";
	static final String DFA468_specialS = "\5\uffff}>";
	static final String[] DFA468_transitionS = { "\1\1",
			"\5\2\1\4\3\uffff\1\3", "\5\2\1\4\3\uffff\1\3", "", "" };

	static final short[] DFA468_eot = DFA.unpackEncodedString(DFA468_eotS);
	static final short[] DFA468_eof = DFA.unpackEncodedString(DFA468_eofS);
	static final char[] DFA468_min = DFA
		.unpackEncodedStringToUnsignedChars(DFA468_minS);
	static final char[] DFA468_max = DFA
		.unpackEncodedStringToUnsignedChars(DFA468_maxS);
	static final short[] DFA468_accept = DFA
		.unpackEncodedString(DFA468_acceptS);
	static final short[] DFA468_special = DFA
		.unpackEncodedString(DFA468_specialS);
	static final short[][] DFA468_transition;

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

	class DFA468 extends DFA {

		public DFA468(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 468;
			this.eot = DFA468_eot;
			this.eof = DFA468_eof;
			this.min = DFA468_min;
			this.max = DFA468_max;
			this.accept = DFA468_accept;
			this.special = DFA468_special;
			this.transition = DFA468_transition;
		}
		public String getDescription() {
			return "1234:9: ( specificcatchclauses )?";
		}
	}

}
