examples/org.eclipse.qvto.examples.xtext.imperativeocl/src-gen/org/eclipse/qvto/examples/xtext/imperativeocl/services/ImperativeOCLGrammarAccess.java

/*
 * generated by Xtext
 */
package org.eclipse.qvto.examples.xtext.imperativeocl.services;

import com.google.inject.Singleton;
import com.google.inject.Inject;

import java.util.List;

import org.eclipse.xtext.*;
import org.eclipse.xtext.service.GrammarProvider;
import org.eclipse.xtext.service.AbstractElementFinder.*;

import org.eclipse.ocl.xtext.essentialocl.services.EssentialOCLGrammarAccess;
import org.eclipse.ocl.xtext.base.services.BaseGrammarAccess;

@Singleton
public class ImperativeOCLGrammarAccess extends AbstractGrammarElementFinder {


	public class GrammmarCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.GrammmarCS");
		private final RuleCall cImperativeOCLExpCSParserRuleCall = (RuleCall)rule.eContents().get(1);

		//GrammmarCS essentialocl::ExpCS:
		//	ImperativeOCLExpCS;
		@Override public ParserRule getRule() { return rule; }

		//ImperativeOCLExpCS
		public RuleCall getImperativeOCLExpCSParserRuleCall() { return cImperativeOCLExpCSParserRuleCall; }
	}

	public class ImperativeOCLExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ImperativeOCLExpCS");
		private final RuleCall cExpCSParserRuleCall = (RuleCall)rule.eContents().get(1);

		////ImperativeOCLReservedKeyword:
		// //	'default'
		// //	| 'elif'
		// //	| RESOLVE_KIND
		// //	| RESOLVE_IN_KIND;
		// //
		//
		////ImperativeOCLPrefixOperator:
		// //	'#' | '##' | '*';
		// //
		// //ImperativeOCLInfixOperator:
		//
		////	ASSIGN_OP | 'default' | '==';
		// //
		// //ImperativeOCLNavigationOperator:
		// //	'!->';
		// //PrefixOperator:
		//
		////	EssentialOCLPrefixOperator | QVToPrefixOperator;
		// //
		// //InfixOperator:
		//
		////	EssentialOCLInfixOperator | QVToInfixOperator;
		// //
		// //NavigationOperator:
		//
		////	EssentialOCLNavigationOperator | QVToNavigationOperator;
		// ImperativeOCLExpCS essentialocl::ExpCS:
		//	ExpCS;
		@Override public ParserRule getRule() { return rule; }

		//ExpCS
		public RuleCall getExpCSParserRuleCall() { return cExpCSParserRuleCall; }
	}

	public class TypeLiteralCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.TypeLiteralCS");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final RuleCall cPrimitiveTypeCSParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
		private final RuleCall cCollectionTypeCSParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
		private final RuleCall cMapTypeCSParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
		private final RuleCall cTupleTypeCSParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
		private final RuleCall cListTypeCSParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4);
		private final RuleCall cDictTypeCSParserRuleCall_5 = (RuleCall)cAlternatives.eContents().get(5);

		//// ********* ImperativeOCL Types *********
		// // TypeLiteralCS redefined to include the new List and Dict types
		//
		//// FIXME refactor its definition in EssentialOCL to allow extension
		// TypeLiteralCS base::TypedRefCS:
		//	PrimitiveTypeCS | CollectionTypeCS | MapTypeCS | TupleTypeCS | ListTypeCS | DictTypeCS;
		@Override public ParserRule getRule() { return rule; }

		//PrimitiveTypeCS | CollectionTypeCS | MapTypeCS | TupleTypeCS | ListTypeCS | DictTypeCS
		public Alternatives getAlternatives() { return cAlternatives; }

		//PrimitiveTypeCS
		public RuleCall getPrimitiveTypeCSParserRuleCall_0() { return cPrimitiveTypeCSParserRuleCall_0; }

		//CollectionTypeCS
		public RuleCall getCollectionTypeCSParserRuleCall_1() { return cCollectionTypeCSParserRuleCall_1; }

		//MapTypeCS
		public RuleCall getMapTypeCSParserRuleCall_2() { return cMapTypeCSParserRuleCall_2; }

		//TupleTypeCS
		public RuleCall getTupleTypeCSParserRuleCall_3() { return cTupleTypeCSParserRuleCall_3; }

		//ListTypeCS
		public RuleCall getListTypeCSParserRuleCall_4() { return cListTypeCSParserRuleCall_4; }

		//DictTypeCS
		public RuleCall getDictTypeCSParserRuleCall_5() { return cDictTypeCSParserRuleCall_5; }
	}

	public class ListTypeCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ListTypeCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cListKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Assignment cOwnedTypeRefAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cOwnedTypeRefTypeExpCSParserRuleCall_2_0 = (RuleCall)cOwnedTypeRefAssignment_2.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3);

		//ListTypeCS:
		//	'List' '(' ownedTypeRef=TypeExpCS ')';
		@Override public ParserRule getRule() { return rule; }

		//'List' '(' ownedTypeRef=TypeExpCS ')'
		public Group getGroup() { return cGroup; }

		//'List'
		public Keyword getListKeyword_0() { return cListKeyword_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//ownedTypeRef=TypeExpCS
		public Assignment getOwnedTypeRefAssignment_2() { return cOwnedTypeRefAssignment_2; }

		//TypeExpCS
		public RuleCall getOwnedTypeRefTypeExpCSParserRuleCall_2_0() { return cOwnedTypeRefTypeExpCSParserRuleCall_2_0; }

		//')'
		public Keyword getRightParenthesisKeyword_3() { return cRightParenthesisKeyword_3; }
	}

	public class DictTypeCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.DictTypeCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cDictKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Assignment cOwnedKeyTypeRefAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cOwnedKeyTypeRefTypeExpCSParserRuleCall_2_0 = (RuleCall)cOwnedKeyTypeRefAssignment_2.eContents().get(0);
		private final Keyword cCommaKeyword_3 = (Keyword)cGroup.eContents().get(3);
		private final Assignment cOwnedValueTypeRefAssignment_4 = (Assignment)cGroup.eContents().get(4);
		private final RuleCall cOwnedValueTypeRefTypeExpCSParserRuleCall_4_0 = (RuleCall)cOwnedValueTypeRefAssignment_4.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);

		//DictTypeCS:
		//	'Dict' '(' ownedKeyTypeRef=TypeExpCS ',' ownedValueTypeRef=TypeExpCS ')';
		@Override public ParserRule getRule() { return rule; }

		//'Dict' '(' ownedKeyTypeRef=TypeExpCS ',' ownedValueTypeRef=TypeExpCS ')'
		public Group getGroup() { return cGroup; }

		//'Dict'
		public Keyword getDictKeyword_0() { return cDictKeyword_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//ownedKeyTypeRef=TypeExpCS
		public Assignment getOwnedKeyTypeRefAssignment_2() { return cOwnedKeyTypeRefAssignment_2; }

		//TypeExpCS
		public RuleCall getOwnedKeyTypeRefTypeExpCSParserRuleCall_2_0() { return cOwnedKeyTypeRefTypeExpCSParserRuleCall_2_0; }

		//','
		public Keyword getCommaKeyword_3() { return cCommaKeyword_3; }

		//ownedValueTypeRef=TypeExpCS
		public Assignment getOwnedValueTypeRefAssignment_4() { return cOwnedValueTypeRefAssignment_4; }

		//TypeExpCS
		public RuleCall getOwnedValueTypeRefTypeExpCSParserRuleCall_4_0() { return cOwnedValueTypeRefTypeExpCSParserRuleCall_4_0; }

		//')'
		public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }
	}

	public class PrimaryExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.PrimaryExpCS");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final RuleCall cNestedExpCSParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
		private final RuleCall cIfExpCSParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
		private final RuleCall cSelfExpCSParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
		private final RuleCall cPrimitiveLiteralExpCSParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
		private final RuleCall cTupleLiteralExpCSParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4);
		private final RuleCall cMapLiteralExpCSParserRuleCall_5 = (RuleCall)cAlternatives.eContents().get(5);
		private final RuleCall cCollectionLiteralExpCSParserRuleCall_6 = (RuleCall)cAlternatives.eContents().get(6);
		private final RuleCall cLambdaLiteralExpCSParserRuleCall_7 = (RuleCall)cAlternatives.eContents().get(7);
		private final RuleCall cImperativeExpCSParserRuleCall_8 = (RuleCall)cAlternatives.eContents().get(8);
		private final RuleCall cNameExpCSParserRuleCall_9 = (RuleCall)cAlternatives.eContents().get(9);

		//// Typedef is deprecated
		// // ********* ImperativeOCL Expressions *********
		//
		//// PrimaryExpCS redefined to include the new List and Dict literal expressions
		//
		//// FIXME refactor its definition in EssentialOCL to allow extension
		// PrimaryExpCS essentialocl::ExpCS:
		//	NestedExpCS | IfExpCS | SelfExpCS | PrimitiveLiteralExpCS | TupleLiteralExpCS | MapLiteralExpCS |
		//	CollectionLiteralExpCS | LambdaLiteralExpCS | ImperativeExpCS | NameExpCS;
		@Override public ParserRule getRule() { return rule; }

		//// These rules are ordered most rejectable first
		// NestedExpCS | IfExpCS | SelfExpCS | PrimitiveLiteralExpCS |
		//TupleLiteralExpCS | MapLiteralExpCS | CollectionLiteralExpCS | LambdaLiteralExpCS | ImperativeExpCS | NameExpCS
		public Alternatives getAlternatives() { return cAlternatives; }

		//// These rules are ordered most rejectable first
		// NestedExpCS
		public RuleCall getNestedExpCSParserRuleCall_0() { return cNestedExpCSParserRuleCall_0; }

		//IfExpCS
		public RuleCall getIfExpCSParserRuleCall_1() { return cIfExpCSParserRuleCall_1; }

		//SelfExpCS
		public RuleCall getSelfExpCSParserRuleCall_2() { return cSelfExpCSParserRuleCall_2; }

		//PrimitiveLiteralExpCS
		public RuleCall getPrimitiveLiteralExpCSParserRuleCall_3() { return cPrimitiveLiteralExpCSParserRuleCall_3; }

		//TupleLiteralExpCS
		public RuleCall getTupleLiteralExpCSParserRuleCall_4() { return cTupleLiteralExpCSParserRuleCall_4; }

		//MapLiteralExpCS
		public RuleCall getMapLiteralExpCSParserRuleCall_5() { return cMapLiteralExpCSParserRuleCall_5; }

		//CollectionLiteralExpCS
		public RuleCall getCollectionLiteralExpCSParserRuleCall_6() { return cCollectionLiteralExpCSParserRuleCall_6; }

		//LambdaLiteralExpCS
		public RuleCall getLambdaLiteralExpCSParserRuleCall_7() { return cLambdaLiteralExpCSParserRuleCall_7; }

		//ImperativeExpCS
		public RuleCall getImperativeExpCSParserRuleCall_8() { return cImperativeExpCSParserRuleCall_8; }

		//NameExpCS
		public RuleCall getNameExpCSParserRuleCall_9() { return cNameExpCSParserRuleCall_9; }
	}

	public class ImperativeExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ImperativeExpCS");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final RuleCall cExpressionBlockCSParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
		private final RuleCall cAssertExpCSParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
		private final RuleCall cBreakExpCSParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
		private final RuleCall cContinueExpCSParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
		private final RuleCall cInstantiationExpCSParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4);
		private final RuleCall cLogExpCSParserRuleCall_5 = (RuleCall)cAlternatives.eContents().get(5);
		private final RuleCall cRaiseExpCSParserRuleCall_6 = (RuleCall)cAlternatives.eContents().get(6);
		private final RuleCall cVarsInitializationCSParserRuleCall_7 = (RuleCall)cAlternatives.eContents().get(7);
		private final RuleCall cListLiteralExpCSParserRuleCall_8 = (RuleCall)cAlternatives.eContents().get(8);
		private final RuleCall cDictLiteralExpCSParserRuleCall_9 = (RuleCall)cAlternatives.eContents().get(9);
		private final RuleCall cTypeLiteralExpCSParserRuleCall_10 = (RuleCall)cAlternatives.eContents().get(10);
		private final RuleCall cReturnExpCSParserRuleCall_11 = (RuleCall)cAlternatives.eContents().get(11);
		private final RuleCall cComputeExpCSParserRuleCall_12 = (RuleCall)cAlternatives.eContents().get(12);
		private final RuleCall cForExpCSParserRuleCall_13 = (RuleCall)cAlternatives.eContents().get(13);
		private final RuleCall cWhileExpCSParserRuleCall_14 = (RuleCall)cAlternatives.eContents().get(14);
		private final RuleCall cImperativeIterateExpCSParserRuleCall_15 = (RuleCall)cAlternatives.eContents().get(15);
		private final RuleCall cSwitchExpCSParserRuleCall_16 = (RuleCall)cAlternatives.eContents().get(16);
		private final RuleCall cAssignExpCSParserRuleCall_17 = (RuleCall)cAlternatives.eContents().get(17);
		private final RuleCall cTryExpCSParserRuleCall_18 = (RuleCall)cAlternatives.eContents().get(18);

		//ImperativeExpCS essentialocl::ExpCS:
		//	ExpressionBlockCS | AssertExpCS | BreakExpCS | ContinueExpCS | InstantiationExpCS | LogExpCS | RaiseExpCS |
		//	VarsInitializationCS | ListLiteralExpCS | DictLiteralExpCS | TypeLiteralExpCS | ReturnExpCS | ComputeExpCS | ForExpCS
		//	| WhileExpCS | ImperativeIterateExpCS | SwitchExpCS | AssignExpCS | TryExpCS;
		@Override public ParserRule getRule() { return rule; }

		//ExpressionBlockCS | AssertExpCS | BreakExpCS | ContinueExpCS | InstantiationExpCS | LogExpCS | RaiseExpCS |
		//VarsInitializationCS | ListLiteralExpCS | DictLiteralExpCS | TypeLiteralExpCS | ReturnExpCS | ComputeExpCS | ForExpCS
		//| WhileExpCS | ImperativeIterateExpCS | SwitchExpCS | AssignExpCS | TryExpCS
		public Alternatives getAlternatives() { return cAlternatives; }

		//ExpressionBlockCS
		public RuleCall getExpressionBlockCSParserRuleCall_0() { return cExpressionBlockCSParserRuleCall_0; }

		//AssertExpCS
		public RuleCall getAssertExpCSParserRuleCall_1() { return cAssertExpCSParserRuleCall_1; }

		//BreakExpCS
		public RuleCall getBreakExpCSParserRuleCall_2() { return cBreakExpCSParserRuleCall_2; }

		//ContinueExpCS
		public RuleCall getContinueExpCSParserRuleCall_3() { return cContinueExpCSParserRuleCall_3; }

		//InstantiationExpCS
		public RuleCall getInstantiationExpCSParserRuleCall_4() { return cInstantiationExpCSParserRuleCall_4; }

		//LogExpCS
		public RuleCall getLogExpCSParserRuleCall_5() { return cLogExpCSParserRuleCall_5; }

		//RaiseExpCS
		public RuleCall getRaiseExpCSParserRuleCall_6() { return cRaiseExpCSParserRuleCall_6; }

		//VarsInitializationCS
		public RuleCall getVarsInitializationCSParserRuleCall_7() { return cVarsInitializationCSParserRuleCall_7; }

		//ListLiteralExpCS
		public RuleCall getListLiteralExpCSParserRuleCall_8() { return cListLiteralExpCSParserRuleCall_8; }

		//DictLiteralExpCS
		public RuleCall getDictLiteralExpCSParserRuleCall_9() { return cDictLiteralExpCSParserRuleCall_9; }

		//TypeLiteralExpCS
		public RuleCall getTypeLiteralExpCSParserRuleCall_10() { return cTypeLiteralExpCSParserRuleCall_10; }

		//ReturnExpCS
		public RuleCall getReturnExpCSParserRuleCall_11() { return cReturnExpCSParserRuleCall_11; }

		//ComputeExpCS
		public RuleCall getComputeExpCSParserRuleCall_12() { return cComputeExpCSParserRuleCall_12; }

		//ForExpCS
		public RuleCall getForExpCSParserRuleCall_13() { return cForExpCSParserRuleCall_13; }

		//WhileExpCS
		public RuleCall getWhileExpCSParserRuleCall_14() { return cWhileExpCSParserRuleCall_14; }

		//ImperativeIterateExpCS
		public RuleCall getImperativeIterateExpCSParserRuleCall_15() { return cImperativeIterateExpCSParserRuleCall_15; }

		//SwitchExpCS
		public RuleCall getSwitchExpCSParserRuleCall_16() { return cSwitchExpCSParserRuleCall_16; }

		//AssignExpCS
		public RuleCall getAssignExpCSParserRuleCall_17() { return cAssignExpCSParserRuleCall_17; }

		//TryExpCS
		public RuleCall getTryExpCSParserRuleCall_18() { return cTryExpCSParserRuleCall_18; }
	}

	public class AssertExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.AssertExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cAssertKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Assignment cSeverityAssignment_1 = (Assignment)cGroup.eContents().get(1);
		private final RuleCall cSeveritySeverityKindCSEnumRuleCall_1_0 = (RuleCall)cSeverityAssignment_1.eContents().get(0);
		private final Assignment cOwnedAssertionAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cOwnedAssertionExpCSParserRuleCall_2_0 = (RuleCall)cOwnedAssertionAssignment_2.eContents().get(0);
		private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
		private final Keyword cWithKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0);
		private final Assignment cOwnedLogAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1);
		private final RuleCall cOwnedLogLogExpCSParserRuleCall_3_1_0 = (RuleCall)cOwnedLogAssignment_3_1.eContents().get(0);

		//AssertExpCS:
		//	'assert' severity=SeverityKindCS? ownedAssertion=ExpCS ('with' ownedLog=LogExpCS)?;
		@Override public ParserRule getRule() { return rule; }

		//'assert' severity=SeverityKindCS? ownedAssertion=ExpCS ('with' ownedLog=LogExpCS)?
		public Group getGroup() { return cGroup; }

		//'assert'
		public Keyword getAssertKeyword_0() { return cAssertKeyword_0; }

		//severity=SeverityKindCS?
		public Assignment getSeverityAssignment_1() { return cSeverityAssignment_1; }

		//SeverityKindCS
		public RuleCall getSeveritySeverityKindCSEnumRuleCall_1_0() { return cSeveritySeverityKindCSEnumRuleCall_1_0; }

		//ownedAssertion=ExpCS
		public Assignment getOwnedAssertionAssignment_2() { return cOwnedAssertionAssignment_2; }

		//ExpCS
		public RuleCall getOwnedAssertionExpCSParserRuleCall_2_0() { return cOwnedAssertionExpCSParserRuleCall_2_0; }

		//('with' ownedLog=LogExpCS)?
		public Group getGroup_3() { return cGroup_3; }

		//'with'
		public Keyword getWithKeyword_3_0() { return cWithKeyword_3_0; }

		//ownedLog=LogExpCS
		public Assignment getOwnedLogAssignment_3_1() { return cOwnedLogAssignment_3_1; }

		//LogExpCS
		public RuleCall getOwnedLogLogExpCSParserRuleCall_3_1_0() { return cOwnedLogLogExpCSParserRuleCall_3_1_0; }
	}

	public class AssignExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.AssignExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Assignment cOwnedLeftAssignment_0 = (Assignment)cGroup.eContents().get(0);
		private final RuleCall cOwnedLeftNameExpCSParserRuleCall_0_0 = (RuleCall)cOwnedLeftAssignment_0.eContents().get(0);
		private final Assignment cAssignOpAssignment_1 = (Assignment)cGroup.eContents().get(1);
		private final RuleCall cAssignOpAssignOpCSEnumRuleCall_1_0 = (RuleCall)cAssignOpAssignment_1.eContents().get(0);
		private final Assignment cOwnedValueAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cOwnedValueExpCSParserRuleCall_2_0 = (RuleCall)cOwnedValueAssignment_2.eContents().get(0);
		private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
		private final Keyword cDefaultKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0);
		private final Assignment cOwnedDefaultAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1);
		private final RuleCall cOwnedDefaultExpCSParserRuleCall_3_1_0 = (RuleCall)cOwnedDefaultAssignment_3_1.eContents().get(0);

		//AssignExpCS:
		//	ownedLeft=NameExpCS assignOp=AssignOpCS ownedValue=ExpCS ('default' ownedDefault=ExpCS)?;
		@Override public ParserRule getRule() { return rule; }

		//ownedLeft=NameExpCS assignOp=AssignOpCS ownedValue=ExpCS ('default' ownedDefault=ExpCS)?
		public Group getGroup() { return cGroup; }

		//ownedLeft=NameExpCS
		public Assignment getOwnedLeftAssignment_0() { return cOwnedLeftAssignment_0; }

		//NameExpCS
		public RuleCall getOwnedLeftNameExpCSParserRuleCall_0_0() { return cOwnedLeftNameExpCSParserRuleCall_0_0; }

		//assignOp=AssignOpCS
		public Assignment getAssignOpAssignment_1() { return cAssignOpAssignment_1; }

		//AssignOpCS
		public RuleCall getAssignOpAssignOpCSEnumRuleCall_1_0() { return cAssignOpAssignOpCSEnumRuleCall_1_0; }

		//ownedValue=ExpCS
		public Assignment getOwnedValueAssignment_2() { return cOwnedValueAssignment_2; }

		//ExpCS
		public RuleCall getOwnedValueExpCSParserRuleCall_2_0() { return cOwnedValueExpCSParserRuleCall_2_0; }

		//('default' ownedDefault=ExpCS)?
		public Group getGroup_3() { return cGroup_3; }

		//'default'
		public Keyword getDefaultKeyword_3_0() { return cDefaultKeyword_3_0; }

		//ownedDefault=ExpCS
		public Assignment getOwnedDefaultAssignment_3_1() { return cOwnedDefaultAssignment_3_1; }

		//ExpCS
		public RuleCall getOwnedDefaultExpCSParserRuleCall_3_1_0() { return cOwnedDefaultExpCSParserRuleCall_3_1_0; }
	}

	public class BreakExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.BreakExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Action cBreakExpCSAction_0 = (Action)cGroup.eContents().get(0);
		private final Keyword cBreakKeyword_1 = (Keyword)cGroup.eContents().get(1);

		//BreakExpCS:
		//	{BreakExpCS} 'break';
		@Override public ParserRule getRule() { return rule; }

		//{BreakExpCS} 'break'
		public Group getGroup() { return cGroup; }

		//{BreakExpCS}
		public Action getBreakExpCSAction_0() { return cBreakExpCSAction_0; }

		//'break'
		public Keyword getBreakKeyword_1() { return cBreakKeyword_1; }
	}

	public class CatchExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.CatchExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cExceptKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
		private final Assignment cVarNameAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0);
		private final RuleCall cVarNameUnrestrictedNameParserRuleCall_2_0_0 = (RuleCall)cVarNameAssignment_2_0.eContents().get(0);
		private final Keyword cColonKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1);
		private final Assignment cOwnedExceptionRefsAssignment_3 = (Assignment)cGroup.eContents().get(3);
		private final RuleCall cOwnedExceptionRefsTypeExpCSParserRuleCall_3_0 = (RuleCall)cOwnedExceptionRefsAssignment_3.eContents().get(0);
		private final Group cGroup_4 = (Group)cGroup.eContents().get(4);
		private final Keyword cCommaKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0);
		private final Assignment cOwnedExceptionRefsAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1);
		private final RuleCall cOwnedExceptionRefsTypeExpCSParserRuleCall_4_1_0 = (RuleCall)cOwnedExceptionRefsAssignment_4_1.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);
		private final Keyword cLeftCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6);
		private final Assignment cOwnedExpsAssignment_7 = (Assignment)cGroup.eContents().get(7);
		private final RuleCall cOwnedExpsExpCSParserRuleCall_7_0 = (RuleCall)cOwnedExpsAssignment_7.eContents().get(0);
		private final Keyword cRightCurlyBracketKeyword_8 = (Keyword)cGroup.eContents().get(8);

		//CatchExpCS:
		//	'except' '(' (varName=UnrestrictedName ':')? ownedExceptionRefs+=TypeExpCS (',' ownedExceptionRefs+=TypeExpCS)* ')'
		//	'{' ownedExps+=ExpCS* '}';
		@Override public ParserRule getRule() { return rule; }

		//'except' '(' (varName=UnrestrictedName ':')? ownedExceptionRefs+=TypeExpCS (',' ownedExceptionRefs+=TypeExpCS)* ')' '{'
		//ownedExps+=ExpCS* '}'
		public Group getGroup() { return cGroup; }

		//'except'
		public Keyword getExceptKeyword_0() { return cExceptKeyword_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//(varName=UnrestrictedName ':')?
		public Group getGroup_2() { return cGroup_2; }

		//varName=UnrestrictedName
		public Assignment getVarNameAssignment_2_0() { return cVarNameAssignment_2_0; }

		//UnrestrictedName
		public RuleCall getVarNameUnrestrictedNameParserRuleCall_2_0_0() { return cVarNameUnrestrictedNameParserRuleCall_2_0_0; }

		//':'
		public Keyword getColonKeyword_2_1() { return cColonKeyword_2_1; }

		//ownedExceptionRefs+=TypeExpCS
		public Assignment getOwnedExceptionRefsAssignment_3() { return cOwnedExceptionRefsAssignment_3; }

		//TypeExpCS
		public RuleCall getOwnedExceptionRefsTypeExpCSParserRuleCall_3_0() { return cOwnedExceptionRefsTypeExpCSParserRuleCall_3_0; }

		//(',' ownedExceptionRefs+=TypeExpCS)*
		public Group getGroup_4() { return cGroup_4; }

		//','
		public Keyword getCommaKeyword_4_0() { return cCommaKeyword_4_0; }

		//ownedExceptionRefs+=TypeExpCS
		public Assignment getOwnedExceptionRefsAssignment_4_1() { return cOwnedExceptionRefsAssignment_4_1; }

		//TypeExpCS
		public RuleCall getOwnedExceptionRefsTypeExpCSParserRuleCall_4_1_0() { return cOwnedExceptionRefsTypeExpCSParserRuleCall_4_1_0; }

		//')'
		public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }

		//'{'
		public Keyword getLeftCurlyBracketKeyword_6() { return cLeftCurlyBracketKeyword_6; }

		//ownedExps+=ExpCS*
		public Assignment getOwnedExpsAssignment_7() { return cOwnedExpsAssignment_7; }

		//ExpCS
		public RuleCall getOwnedExpsExpCSParserRuleCall_7_0() { return cOwnedExpsExpCSParserRuleCall_7_0; }

		//'}'
		public Keyword getRightCurlyBracketKeyword_8() { return cRightCurlyBracketKeyword_8; }
	}

	public class ComputeExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ComputeExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cComputeKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Assignment cOwnedResultVarAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cOwnedResultVarVarDeclarationCSParserRuleCall_2_0 = (RuleCall)cOwnedResultVarAssignment_2.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3);
		private final Keyword cLeftCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4);
		private final Assignment cOwnedExpsAssignment_5 = (Assignment)cGroup.eContents().get(5);
		private final RuleCall cOwnedExpsExpressionStatementCSParserRuleCall_5_0 = (RuleCall)cOwnedExpsAssignment_5.eContents().get(0);
		private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6);

		//ComputeExpCS:
		//	'compute' '(' ownedResultVar=VarDeclarationCS ')' '{' ownedExps+=ExpressionStatementCS '}';
		@Override public ParserRule getRule() { return rule; }

		//'compute' '(' ownedResultVar=VarDeclarationCS ')' '{' ownedExps+=ExpressionStatementCS '}'
		public Group getGroup() { return cGroup; }

		//'compute'
		public Keyword getComputeKeyword_0() { return cComputeKeyword_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//ownedResultVar=VarDeclarationCS
		public Assignment getOwnedResultVarAssignment_2() { return cOwnedResultVarAssignment_2; }

		//VarDeclarationCS
		public RuleCall getOwnedResultVarVarDeclarationCSParserRuleCall_2_0() { return cOwnedResultVarVarDeclarationCSParserRuleCall_2_0; }

		//')'
		public Keyword getRightParenthesisKeyword_3() { return cRightParenthesisKeyword_3; }

		//'{'
		public Keyword getLeftCurlyBracketKeyword_4() { return cLeftCurlyBracketKeyword_4; }

		//ownedExps+=ExpressionStatementCS
		public Assignment getOwnedExpsAssignment_5() { return cOwnedExpsAssignment_5; }

		//ExpressionStatementCS
		public RuleCall getOwnedExpsExpressionStatementCSParserRuleCall_5_0() { return cOwnedExpsExpressionStatementCSParserRuleCall_5_0; }

		//'}'
		public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; }
	}

	public class ContinueExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ContinueExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Action cContinueExpCSAction_0 = (Action)cGroup.eContents().get(0);
		private final Keyword cContinueKeyword_1 = (Keyword)cGroup.eContents().get(1);

		//ContinueExpCS:
		//	{ContinueExpCS} 'continue';
		@Override public ParserRule getRule() { return rule; }

		//{ContinueExpCS} 'continue'
		public Group getGroup() { return cGroup; }

		//{ContinueExpCS}
		public Action getContinueExpCSAction_0() { return cContinueExpCSAction_0; }

		//'continue'
		public Keyword getContinueKeyword_1() { return cContinueKeyword_1; }
	}

	public class DictLiteralExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.DictLiteralExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cDictKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Action cDictLiteralExpCSAction_2 = (Action)cGroup.eContents().get(2);
		private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
		private final Assignment cOwnedPartsAssignment_3_0 = (Assignment)cGroup_3.eContents().get(0);
		private final RuleCall cOwnedPartsDictLiteralPartCSParserRuleCall_3_0_0 = (RuleCall)cOwnedPartsAssignment_3_0.eContents().get(0);
		private final Group cGroup_3_1 = (Group)cGroup_3.eContents().get(1);
		private final Keyword cCommaKeyword_3_1_0 = (Keyword)cGroup_3_1.eContents().get(0);
		private final Assignment cOwnedPartsAssignment_3_1_1 = (Assignment)cGroup_3_1.eContents().get(1);
		private final RuleCall cOwnedPartsDictLiteralPartCSParserRuleCall_3_1_1_0 = (RuleCall)cOwnedPartsAssignment_3_1_1.eContents().get(0);
		private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4);

		//DictLiteralExpCS:
		//	'Dict' '{' {DictLiteralExpCS} (ownedParts+=DictLiteralPartCS (',' ownedParts+=DictLiteralPartCS)*)? '}';
		@Override public ParserRule getRule() { return rule; }

		//'Dict' '{' {DictLiteralExpCS} (ownedParts+=DictLiteralPartCS (',' ownedParts+=DictLiteralPartCS)*)? '}'
		public Group getGroup() { return cGroup; }

		//'Dict'
		public Keyword getDictKeyword_0() { return cDictKeyword_0; }

		//'{'
		public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; }

		//{DictLiteralExpCS}
		public Action getDictLiteralExpCSAction_2() { return cDictLiteralExpCSAction_2; }

		//(ownedParts+=DictLiteralPartCS (',' ownedParts+=DictLiteralPartCS)*)?
		public Group getGroup_3() { return cGroup_3; }

		//ownedParts+=DictLiteralPartCS
		public Assignment getOwnedPartsAssignment_3_0() { return cOwnedPartsAssignment_3_0; }

		//DictLiteralPartCS
		public RuleCall getOwnedPartsDictLiteralPartCSParserRuleCall_3_0_0() { return cOwnedPartsDictLiteralPartCSParserRuleCall_3_0_0; }

		//(',' ownedParts+=DictLiteralPartCS)*
		public Group getGroup_3_1() { return cGroup_3_1; }

		//','
		public Keyword getCommaKeyword_3_1_0() { return cCommaKeyword_3_1_0; }

		//ownedParts+=DictLiteralPartCS
		public Assignment getOwnedPartsAssignment_3_1_1() { return cOwnedPartsAssignment_3_1_1; }

		//DictLiteralPartCS
		public RuleCall getOwnedPartsDictLiteralPartCSParserRuleCall_3_1_1_0() { return cOwnedPartsDictLiteralPartCSParserRuleCall_3_1_1_0; }

		//'}'
		public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; }
	}

	public class DictLiteralPartCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.DictLiteralPartCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Assignment cOwnedKeyAssignment_0 = (Assignment)cGroup.eContents().get(0);
		private final RuleCall cOwnedKeyPrimitiveLiteralExpCSParserRuleCall_0_0 = (RuleCall)cOwnedKeyAssignment_0.eContents().get(0);
		private final Keyword cEqualsSignKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Assignment cOwnedValueAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cOwnedValueExpCSParserRuleCall_2_0 = (RuleCall)cOwnedValueAssignment_2.eContents().get(0);

		//DictLiteralPartCS:
		//	ownedKey=PrimitiveLiteralExpCS '=' ownedValue=ExpCS;
		@Override public ParserRule getRule() { return rule; }

		//ownedKey=PrimitiveLiteralExpCS '=' ownedValue=ExpCS
		public Group getGroup() { return cGroup; }

		//ownedKey=PrimitiveLiteralExpCS
		public Assignment getOwnedKeyAssignment_0() { return cOwnedKeyAssignment_0; }

		//PrimitiveLiteralExpCS
		public RuleCall getOwnedKeyPrimitiveLiteralExpCSParserRuleCall_0_0() { return cOwnedKeyPrimitiveLiteralExpCSParserRuleCall_0_0; }

		//'='
		public Keyword getEqualsSignKeyword_1() { return cEqualsSignKeyword_1; }

		//ownedValue=ExpCS
		public Assignment getOwnedValueAssignment_2() { return cOwnedValueAssignment_2; }

		//ExpCS
		public RuleCall getOwnedValueExpCSParserRuleCall_2_0() { return cOwnedValueExpCSParserRuleCall_2_0; }
	}

	public class ExpressionBlockCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ExpressionBlockCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Action cExpressionBlockCSAction_0 = (Action)cGroup.eContents().get(0);
		private final Keyword cDoKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2);
		private final Assignment cOwnedExpsAssignment_3 = (Assignment)cGroup.eContents().get(3);
		private final RuleCall cOwnedExpsExpressionStatementCSParserRuleCall_3_0 = (RuleCall)cOwnedExpsAssignment_3.eContents().get(0);
		private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4);

		//ExpressionBlockCS:
		//	{ExpressionBlockCS} 'do'? '{' ownedExps+=ExpressionStatementCS* '}';
		@Override public ParserRule getRule() { return rule; }

		//{ExpressionBlockCS} 'do'? '{' ownedExps+=ExpressionStatementCS* '}'
		public Group getGroup() { return cGroup; }

		//{ExpressionBlockCS}
		public Action getExpressionBlockCSAction_0() { return cExpressionBlockCSAction_0; }

		//'do'?
		public Keyword getDoKeyword_1() { return cDoKeyword_1; }

		//'{'
		public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; }

		//ownedExps+=ExpressionStatementCS*
		public Assignment getOwnedExpsAssignment_3() { return cOwnedExpsAssignment_3; }

		//ExpressionStatementCS
		public RuleCall getOwnedExpsExpressionStatementCSParserRuleCall_3_0() { return cOwnedExpsExpressionStatementCSParserRuleCall_3_0; }

		//'}'
		public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; }
	}

	public class ExpressionStatementCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ExpressionStatementCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final RuleCall cExpCSParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
		private final Keyword cSemicolonKeyword_1 = (Keyword)cGroup.eContents().get(1);

		//ExpressionStatementCS essentialocl::ExpCS:
		//	ExpCS ';'?;
		@Override public ParserRule getRule() { return rule; }

		//ExpCS ';'?
		public Group getGroup() { return cGroup; }

		//ExpCS
		public RuleCall getExpCSParserRuleCall_0() { return cExpCSParserRuleCall_0; }

		//';'?
		public Keyword getSemicolonKeyword_1() { return cSemicolonKeyword_1; }
	}

	public class ExtentRefCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ExtentRefCS");
		private final Assignment cOwnedPathNameAssignment = (Assignment)rule.eContents().get(1);
		private final RuleCall cOwnedPathNamePathNameCSParserRuleCall_0 = (RuleCall)cOwnedPathNameAssignment.eContents().get(0);

		//ExtentRefCS:
		//	ownedPathName=PathNameCS;
		@Override public ParserRule getRule() { return rule; }

		//ownedPathName=PathNameCS
		public Assignment getOwnedPathNameAssignment() { return cOwnedPathNameAssignment; }

		//PathNameCS
		public RuleCall getOwnedPathNamePathNameCSParserRuleCall_0() { return cOwnedPathNamePathNameCSParserRuleCall_0; }
	}

	public class ForExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ForExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0);
		private final Keyword cForEachKeyword_0_0 = (Keyword)cAlternatives_0.eContents().get(0);
		private final Assignment cIsOneAssignment_0_1 = (Assignment)cAlternatives_0.eContents().get(1);
		private final Keyword cIsOneForOneKeyword_0_1_0 = (Keyword)cIsOneAssignment_0_1.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
		private final Assignment cOwnedTargetAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0);
		private final RuleCall cOwnedTargetVarDeclarationCSParserRuleCall_2_0_0 = (RuleCall)cOwnedTargetAssignment_2_0.eContents().get(0);
		private final Keyword cSemicolonKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1);
		private final Assignment cOwnedIteratorAssignment_3 = (Assignment)cGroup.eContents().get(3);
		private final RuleCall cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_3_0 = (RuleCall)cOwnedIteratorAssignment_3.eContents().get(0);
		private final Group cGroup_4 = (Group)cGroup.eContents().get(4);
		private final Keyword cVerticalLineKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0);
		private final Assignment cOwnedConditionAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1);
		private final RuleCall cOwnedConditionExpCSParserRuleCall_4_1_0 = (RuleCall)cOwnedConditionAssignment_4_1.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);
		private final Assignment cOwnedBodyAssignment_6 = (Assignment)cGroup.eContents().get(6);
		private final RuleCall cOwnedBodyExpCSParserRuleCall_6_0 = (RuleCall)cOwnedBodyAssignment_6.eContents().get(0);

		//// FIXME align with NameExpCS
		// ForExpCS:
		//	('forEach' | isOne?='forOne') '(' (ownedTarget=VarDeclarationCS ';')? ownedIterator=VarDeclarationNoInitCS ('|'
		//	ownedCondition=ExpCS)? ')' ownedBody=ExpCS;
		@Override public ParserRule getRule() { return rule; }

		//('forEach' | isOne?='forOne') '(' (ownedTarget=VarDeclarationCS ';')? ownedIterator=VarDeclarationNoInitCS ('|'
		//ownedCondition=ExpCS)? ')' ownedBody=ExpCS
		public Group getGroup() { return cGroup; }

		//'forEach' | isOne?='forOne'
		public Alternatives getAlternatives_0() { return cAlternatives_0; }

		//'forEach'
		public Keyword getForEachKeyword_0_0() { return cForEachKeyword_0_0; }

		//isOne?='forOne'
		public Assignment getIsOneAssignment_0_1() { return cIsOneAssignment_0_1; }

		//'forOne'
		public Keyword getIsOneForOneKeyword_0_1_0() { return cIsOneForOneKeyword_0_1_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//(ownedTarget=VarDeclarationCS ';')?
		public Group getGroup_2() { return cGroup_2; }

		//ownedTarget=VarDeclarationCS
		public Assignment getOwnedTargetAssignment_2_0() { return cOwnedTargetAssignment_2_0; }

		//VarDeclarationCS
		public RuleCall getOwnedTargetVarDeclarationCSParserRuleCall_2_0_0() { return cOwnedTargetVarDeclarationCSParserRuleCall_2_0_0; }

		//';'
		public Keyword getSemicolonKeyword_2_1() { return cSemicolonKeyword_2_1; }

		//ownedIterator=VarDeclarationNoInitCS
		public Assignment getOwnedIteratorAssignment_3() { return cOwnedIteratorAssignment_3; }

		//VarDeclarationNoInitCS
		public RuleCall getOwnedIteratorVarDeclarationNoInitCSParserRuleCall_3_0() { return cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_3_0; }

		//('|' ownedCondition=ExpCS)?
		public Group getGroup_4() { return cGroup_4; }

		//'|'
		public Keyword getVerticalLineKeyword_4_0() { return cVerticalLineKeyword_4_0; }

		//ownedCondition=ExpCS
		public Assignment getOwnedConditionAssignment_4_1() { return cOwnedConditionAssignment_4_1; }

		//ExpCS
		public RuleCall getOwnedConditionExpCSParserRuleCall_4_1_0() { return cOwnedConditionExpCSParserRuleCall_4_1_0; }

		//')'
		public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }

		//ownedBody=ExpCS
		public Assignment getOwnedBodyAssignment_6() { return cOwnedBodyAssignment_6; }

		//ExpCS
		public RuleCall getOwnedBodyExpCSParserRuleCall_6_0() { return cOwnedBodyExpCSParserRuleCall_6_0; }
	}

	public class ImperativeIterateExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ImperativeIterateExpCS");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
		private final Assignment cNameAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0);
		private final Keyword cNameXcollectKeyword_0_0_0 = (Keyword)cNameAssignment_0_0.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1);
		private final Group cGroup_0_2 = (Group)cGroup_0.eContents().get(2);
		private final Assignment cOwnedIteratorAssignment_0_2_0 = (Assignment)cGroup_0_2.eContents().get(0);
		private final RuleCall cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_0_2_0_0 = (RuleCall)cOwnedIteratorAssignment_0_2_0.eContents().get(0);
		private final Keyword cVerticalLineKeyword_0_2_1 = (Keyword)cGroup_0_2.eContents().get(1);
		private final Assignment cOwnedBodyAssignment_0_3 = (Assignment)cGroup_0.eContents().get(3);
		private final RuleCall cOwnedBodyExpCSParserRuleCall_0_3_0 = (RuleCall)cOwnedBodyAssignment_0_3.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_0_4 = (Keyword)cGroup_0.eContents().get(4);
		private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
		private final Assignment cNameAssignment_1_0 = (Assignment)cGroup_1.eContents().get(0);
		private final Alternatives cNameAlternatives_1_0_0 = (Alternatives)cNameAssignment_1_0.eContents().get(0);
		private final Keyword cNameXselectKeyword_1_0_0_0 = (Keyword)cNameAlternatives_1_0_0.eContents().get(0);
		private final Keyword cNameXselectOneKeyword_1_0_0_1 = (Keyword)cNameAlternatives_1_0_0.eContents().get(1);
		private final Keyword cLeftParenthesisKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1);
		private final Group cGroup_1_2 = (Group)cGroup_1.eContents().get(2);
		private final Assignment cOwnedIteratorAssignment_1_2_0 = (Assignment)cGroup_1_2.eContents().get(0);
		private final RuleCall cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_1_2_0_0 = (RuleCall)cOwnedIteratorAssignment_1_2_0.eContents().get(0);
		private final Keyword cVerticalLineKeyword_1_2_1 = (Keyword)cGroup_1_2.eContents().get(1);
		private final Assignment cOwnedConditionAssignment_1_3 = (Assignment)cGroup_1.eContents().get(3);
		private final RuleCall cOwnedConditionExpCSParserRuleCall_1_3_0 = (RuleCall)cOwnedConditionAssignment_1_3.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_1_4 = (Keyword)cGroup_1.eContents().get(4);
		private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2);
		private final Assignment cNameAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0);
		private final Alternatives cNameAlternatives_2_0_0 = (Alternatives)cNameAssignment_2_0.eContents().get(0);
		private final Keyword cNameXcollectselectKeyword_2_0_0_0 = (Keyword)cNameAlternatives_2_0_0.eContents().get(0);
		private final Keyword cNameXcollectselectOneKeyword_2_0_0_1 = (Keyword)cNameAlternatives_2_0_0.eContents().get(1);
		private final Keyword cLeftParenthesisKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1);
		private final Group cGroup_2_2 = (Group)cGroup_2.eContents().get(2);
		private final Assignment cOwnedIteratorAssignment_2_2_0 = (Assignment)cGroup_2_2.eContents().get(0);
		private final RuleCall cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_2_2_0_0 = (RuleCall)cOwnedIteratorAssignment_2_2_0.eContents().get(0);
		private final Keyword cSemicolonKeyword_2_2_1 = (Keyword)cGroup_2_2.eContents().get(1);
		private final Assignment cOwnedTargetAssignment_2_3 = (Assignment)cGroup_2.eContents().get(3);
		private final RuleCall cOwnedTargetVarDeclarationCSParserRuleCall_2_3_0 = (RuleCall)cOwnedTargetAssignment_2_3.eContents().get(0);
		private final Keyword cColonEqualsSignKeyword_2_4 = (Keyword)cGroup_2.eContents().get(4);
		private final Assignment cOwnedBodyAssignment_2_5 = (Assignment)cGroup_2.eContents().get(5);
		private final RuleCall cOwnedBodyExpCSParserRuleCall_2_5_0 = (RuleCall)cOwnedBodyAssignment_2_5.eContents().get(0);
		private final Keyword cVerticalLineKeyword_2_6 = (Keyword)cGroup_2.eContents().get(6);
		private final Assignment cOwnedConditionAssignment_2_7 = (Assignment)cGroup_2.eContents().get(7);
		private final RuleCall cOwnedConditionExpCSParserRuleCall_2_7_0 = (RuleCall)cOwnedConditionAssignment_2_7.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_2_8 = (Keyword)cGroup_2.eContents().get(8);

		//// FIXME align with NameExpCS
		// ImperativeIterateExpCS:
		//	name='xcollect' '(' (ownedIterator=VarDeclarationNoInitCS '|')? ownedBody=ExpCS ')' | name=('xselect' | 'xselectOne')
		//	'(' (ownedIterator=VarDeclarationNoInitCS '|')? ownedCondition=ExpCS ')' | name=('xcollectselect' |
		//	'xcollectselectOne') '(' (ownedIterator=VarDeclarationNoInitCS ';')? ownedTarget=VarDeclarationCS ':='
		//	ownedBody=ExpCS '|' ownedCondition=ExpCS ')';
		@Override public ParserRule getRule() { return rule; }

		//name='xcollect' '(' (ownedIterator=VarDeclarationNoInitCS '|')? ownedBody=ExpCS ')' | name=('xselect' | 'xselectOne')
		//'(' (ownedIterator=VarDeclarationNoInitCS '|')? ownedCondition=ExpCS ')' | name=('xcollectselect' |
		//'xcollectselectOne') '(' (ownedIterator=VarDeclarationNoInitCS ';')? ownedTarget=VarDeclarationCS ':=' ownedBody=ExpCS
		//'|' ownedCondition=ExpCS ')'
		public Alternatives getAlternatives() { return cAlternatives; }

		//name='xcollect' '(' (ownedIterator=VarDeclarationNoInitCS '|')? ownedBody=ExpCS ')'
		public Group getGroup_0() { return cGroup_0; }

		//name='xcollect'
		public Assignment getNameAssignment_0_0() { return cNameAssignment_0_0; }

		//'xcollect'
		public Keyword getNameXcollectKeyword_0_0_0() { return cNameXcollectKeyword_0_0_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_0_1() { return cLeftParenthesisKeyword_0_1; }

		//(ownedIterator=VarDeclarationNoInitCS '|')?
		public Group getGroup_0_2() { return cGroup_0_2; }

		//ownedIterator=VarDeclarationNoInitCS
		public Assignment getOwnedIteratorAssignment_0_2_0() { return cOwnedIteratorAssignment_0_2_0; }

		//VarDeclarationNoInitCS
		public RuleCall getOwnedIteratorVarDeclarationNoInitCSParserRuleCall_0_2_0_0() { return cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_0_2_0_0; }

		//'|'
		public Keyword getVerticalLineKeyword_0_2_1() { return cVerticalLineKeyword_0_2_1; }

		//ownedBody=ExpCS
		public Assignment getOwnedBodyAssignment_0_3() { return cOwnedBodyAssignment_0_3; }

		//ExpCS
		public RuleCall getOwnedBodyExpCSParserRuleCall_0_3_0() { return cOwnedBodyExpCSParserRuleCall_0_3_0; }

		//')'
		public Keyword getRightParenthesisKeyword_0_4() { return cRightParenthesisKeyword_0_4; }

		//name=('xselect' | 'xselectOne') '(' (ownedIterator=VarDeclarationNoInitCS '|')? ownedCondition=ExpCS ')'
		public Group getGroup_1() { return cGroup_1; }

		//name=('xselect' | 'xselectOne')
		public Assignment getNameAssignment_1_0() { return cNameAssignment_1_0; }

		//('xselect' | 'xselectOne')
		public Alternatives getNameAlternatives_1_0_0() { return cNameAlternatives_1_0_0; }

		//'xselect'
		public Keyword getNameXselectKeyword_1_0_0_0() { return cNameXselectKeyword_1_0_0_0; }

		//'xselectOne'
		public Keyword getNameXselectOneKeyword_1_0_0_1() { return cNameXselectOneKeyword_1_0_0_1; }

		//'('
		public Keyword getLeftParenthesisKeyword_1_1() { return cLeftParenthesisKeyword_1_1; }

		//(ownedIterator=VarDeclarationNoInitCS '|')?
		public Group getGroup_1_2() { return cGroup_1_2; }

		//ownedIterator=VarDeclarationNoInitCS
		public Assignment getOwnedIteratorAssignment_1_2_0() { return cOwnedIteratorAssignment_1_2_0; }

		//VarDeclarationNoInitCS
		public RuleCall getOwnedIteratorVarDeclarationNoInitCSParserRuleCall_1_2_0_0() { return cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_1_2_0_0; }

		//'|'
		public Keyword getVerticalLineKeyword_1_2_1() { return cVerticalLineKeyword_1_2_1; }

		//ownedCondition=ExpCS
		public Assignment getOwnedConditionAssignment_1_3() { return cOwnedConditionAssignment_1_3; }

		//ExpCS
		public RuleCall getOwnedConditionExpCSParserRuleCall_1_3_0() { return cOwnedConditionExpCSParserRuleCall_1_3_0; }

		//')'
		public Keyword getRightParenthesisKeyword_1_4() { return cRightParenthesisKeyword_1_4; }

		//name=('xcollectselect' | 'xcollectselectOne') '(' (ownedIterator=VarDeclarationNoInitCS ';')?
		//ownedTarget=VarDeclarationCS ':=' ownedBody=ExpCS '|' ownedCondition=ExpCS ')'
		public Group getGroup_2() { return cGroup_2; }

		//name=('xcollectselect' | 'xcollectselectOne')
		public Assignment getNameAssignment_2_0() { return cNameAssignment_2_0; }

		//('xcollectselect' | 'xcollectselectOne')
		public Alternatives getNameAlternatives_2_0_0() { return cNameAlternatives_2_0_0; }

		//'xcollectselect'
		public Keyword getNameXcollectselectKeyword_2_0_0_0() { return cNameXcollectselectKeyword_2_0_0_0; }

		//'xcollectselectOne'
		public Keyword getNameXcollectselectOneKeyword_2_0_0_1() { return cNameXcollectselectOneKeyword_2_0_0_1; }

		//'('
		public Keyword getLeftParenthesisKeyword_2_1() { return cLeftParenthesisKeyword_2_1; }

		//(ownedIterator=VarDeclarationNoInitCS ';')?
		public Group getGroup_2_2() { return cGroup_2_2; }

		//ownedIterator=VarDeclarationNoInitCS
		public Assignment getOwnedIteratorAssignment_2_2_0() { return cOwnedIteratorAssignment_2_2_0; }

		//VarDeclarationNoInitCS
		public RuleCall getOwnedIteratorVarDeclarationNoInitCSParserRuleCall_2_2_0_0() { return cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_2_2_0_0; }

		//';'
		public Keyword getSemicolonKeyword_2_2_1() { return cSemicolonKeyword_2_2_1; }

		//ownedTarget=VarDeclarationCS
		public Assignment getOwnedTargetAssignment_2_3() { return cOwnedTargetAssignment_2_3; }

		//VarDeclarationCS
		public RuleCall getOwnedTargetVarDeclarationCSParserRuleCall_2_3_0() { return cOwnedTargetVarDeclarationCSParserRuleCall_2_3_0; }

		//':='
		public Keyword getColonEqualsSignKeyword_2_4() { return cColonEqualsSignKeyword_2_4; }

		//ownedBody=ExpCS
		public Assignment getOwnedBodyAssignment_2_5() { return cOwnedBodyAssignment_2_5; }

		//ExpCS
		public RuleCall getOwnedBodyExpCSParserRuleCall_2_5_0() { return cOwnedBodyExpCSParserRuleCall_2_5_0; }

		//'|'
		public Keyword getVerticalLineKeyword_2_6() { return cVerticalLineKeyword_2_6; }

		//ownedCondition=ExpCS
		public Assignment getOwnedConditionAssignment_2_7() { return cOwnedConditionAssignment_2_7; }

		//ExpCS
		public RuleCall getOwnedConditionExpCSParserRuleCall_2_7_0() { return cOwnedConditionExpCSParserRuleCall_2_7_0; }

		//')'
		public Keyword getRightParenthesisKeyword_2_8() { return cRightParenthesisKeyword_2_8; }
	}

	public class InstantiationExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.InstantiationExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cNewKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Assignment cOwnedClassRefAssignment_1 = (Assignment)cGroup.eContents().get(1);
		private final RuleCall cOwnedClassRefTypeExpCSParserRuleCall_1_0 = (RuleCall)cOwnedClassRefAssignment_1.eContents().get(0);
		private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
		private final Keyword cCommercialAtKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0);
		private final Assignment cOwnedExtentRefAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1);
		private final RuleCall cOwnedExtentRefTypeNameExpCSParserRuleCall_2_1_0 = (RuleCall)cOwnedExtentRefAssignment_2_1.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3);
		private final Group cGroup_4 = (Group)cGroup.eContents().get(4);
		private final Assignment cOwnedArgumentsAssignment_4_0 = (Assignment)cGroup_4.eContents().get(0);
		private final RuleCall cOwnedArgumentsExpCSParserRuleCall_4_0_0 = (RuleCall)cOwnedArgumentsAssignment_4_0.eContents().get(0);
		private final Group cGroup_4_1 = (Group)cGroup_4.eContents().get(1);
		private final Keyword cCommaKeyword_4_1_0 = (Keyword)cGroup_4_1.eContents().get(0);
		private final Assignment cOwnedArgumentsAssignment_4_1_1 = (Assignment)cGroup_4_1.eContents().get(1);
		private final RuleCall cOwnedArgumentsExpCSParserRuleCall_4_1_1_0 = (RuleCall)cOwnedArgumentsAssignment_4_1_1.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);

		//// FIXME if a new parameter can specify modelExtent, then it should probably belong to QVTOperational package rather than ImperativeOCL
		//
		//InstantiationExpCS:
		//	'new' ownedClassRef=TypeExpCS ('@' ownedExtentRef=TypeNameExpCS)? '(' (ownedArguments+=ExpCS (','
		//	ownedArguments+=ExpCS)*)? ')';
		@Override public ParserRule getRule() { return rule; }

		//'new' ownedClassRef=TypeExpCS ('@' ownedExtentRef=TypeNameExpCS)? '(' (ownedArguments+=ExpCS (','
		//ownedArguments+=ExpCS)*)? ')'
		public Group getGroup() { return cGroup; }

		//'new'
		public Keyword getNewKeyword_0() { return cNewKeyword_0; }

		//ownedClassRef=TypeExpCS
		public Assignment getOwnedClassRefAssignment_1() { return cOwnedClassRefAssignment_1; }

		//TypeExpCS
		public RuleCall getOwnedClassRefTypeExpCSParserRuleCall_1_0() { return cOwnedClassRefTypeExpCSParserRuleCall_1_0; }

		//('@' ownedExtentRef=TypeNameExpCS)?
		public Group getGroup_2() { return cGroup_2; }

		//'@'
		public Keyword getCommercialAtKeyword_2_0() { return cCommercialAtKeyword_2_0; }

		//ownedExtentRef=TypeNameExpCS
		public Assignment getOwnedExtentRefAssignment_2_1() { return cOwnedExtentRefAssignment_2_1; }

		//TypeNameExpCS
		public RuleCall getOwnedExtentRefTypeNameExpCSParserRuleCall_2_1_0() { return cOwnedExtentRefTypeNameExpCSParserRuleCall_2_1_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_3() { return cLeftParenthesisKeyword_3; }

		//(ownedArguments+=ExpCS (',' ownedArguments+=ExpCS)*)?
		public Group getGroup_4() { return cGroup_4; }

		//ownedArguments+=ExpCS
		public Assignment getOwnedArgumentsAssignment_4_0() { return cOwnedArgumentsAssignment_4_0; }

		//ExpCS
		public RuleCall getOwnedArgumentsExpCSParserRuleCall_4_0_0() { return cOwnedArgumentsExpCSParserRuleCall_4_0_0; }

		//(',' ownedArguments+=ExpCS)*
		public Group getGroup_4_1() { return cGroup_4_1; }

		//','
		public Keyword getCommaKeyword_4_1_0() { return cCommaKeyword_4_1_0; }

		//ownedArguments+=ExpCS
		public Assignment getOwnedArgumentsAssignment_4_1_1() { return cOwnedArgumentsAssignment_4_1_1; }

		//ExpCS
		public RuleCall getOwnedArgumentsExpCSParserRuleCall_4_1_1_0() { return cOwnedArgumentsExpCSParserRuleCall_4_1_1_0; }

		//')'
		public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }
	}

	public class ListLiteralExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ListLiteralExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cListKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Action cListLiteralExpCSAction_2 = (Action)cGroup.eContents().get(2);
		private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
		private final Assignment cOwnedPartsAssignment_3_0 = (Assignment)cGroup_3.eContents().get(0);
		private final RuleCall cOwnedPartsCollectionLiteralPartCSParserRuleCall_3_0_0 = (RuleCall)cOwnedPartsAssignment_3_0.eContents().get(0);
		private final Group cGroup_3_1 = (Group)cGroup_3.eContents().get(1);
		private final Keyword cCommaKeyword_3_1_0 = (Keyword)cGroup_3_1.eContents().get(0);
		private final Assignment cOwnedPartsAssignment_3_1_1 = (Assignment)cGroup_3_1.eContents().get(1);
		private final RuleCall cOwnedPartsCollectionLiteralPartCSParserRuleCall_3_1_1_0 = (RuleCall)cOwnedPartsAssignment_3_1_1.eContents().get(0);
		private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4);

		//ListLiteralExpCS:
		//	'List' '{' {ListLiteralExpCS} (ownedParts+=CollectionLiteralPartCS (',' ownedParts+=CollectionLiteralPartCS)*)? '}';
		@Override public ParserRule getRule() { return rule; }

		//'List' '{' {ListLiteralExpCS} (ownedParts+=CollectionLiteralPartCS (',' ownedParts+=CollectionLiteralPartCS)*)? '}'
		public Group getGroup() { return cGroup; }

		//'List'
		public Keyword getListKeyword_0() { return cListKeyword_0; }

		//'{'
		public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; }

		//{ListLiteralExpCS}
		public Action getListLiteralExpCSAction_2() { return cListLiteralExpCSAction_2; }

		//(ownedParts+=CollectionLiteralPartCS (',' ownedParts+=CollectionLiteralPartCS)*)?
		public Group getGroup_3() { return cGroup_3; }

		//ownedParts+=CollectionLiteralPartCS
		public Assignment getOwnedPartsAssignment_3_0() { return cOwnedPartsAssignment_3_0; }

		//CollectionLiteralPartCS
		public RuleCall getOwnedPartsCollectionLiteralPartCSParserRuleCall_3_0_0() { return cOwnedPartsCollectionLiteralPartCSParserRuleCall_3_0_0; }

		//(',' ownedParts+=CollectionLiteralPartCS)*
		public Group getGroup_3_1() { return cGroup_3_1; }

		//','
		public Keyword getCommaKeyword_3_1_0() { return cCommaKeyword_3_1_0; }

		//ownedParts+=CollectionLiteralPartCS
		public Assignment getOwnedPartsAssignment_3_1_1() { return cOwnedPartsAssignment_3_1_1; }

		//CollectionLiteralPartCS
		public RuleCall getOwnedPartsCollectionLiteralPartCSParserRuleCall_3_1_1_0() { return cOwnedPartsCollectionLiteralPartCSParserRuleCall_3_1_1_0; }

		//'}'
		public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; }
	}

	public class LogExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.LogExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cLogKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Assignment cOwnedMessageAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cOwnedMessageStringLiteralExpCSParserRuleCall_2_0 = (RuleCall)cOwnedMessageAssignment_2.eContents().get(0);
		private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
		private final Keyword cCommaKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0);
		private final Assignment cOwnedElementAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1);
		private final RuleCall cOwnedElementExpCSParserRuleCall_3_1_0 = (RuleCall)cOwnedElementAssignment_3_1.eContents().get(0);
		private final Group cGroup_4 = (Group)cGroup.eContents().get(4);
		private final Keyword cCommaKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0);
		private final Assignment cSeverityAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1);
		private final RuleCall cSeveritySeverityKindCSEnumRuleCall_4_1_0 = (RuleCall)cSeverityAssignment_4_1.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);
		private final Group cGroup_6 = (Group)cGroup.eContents().get(6);
		private final Keyword cWhenKeyword_6_0 = (Keyword)cGroup_6.eContents().get(0);
		private final Assignment cOwnedConditionAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1);
		private final RuleCall cOwnedConditionExpCSParserRuleCall_6_1_0 = (RuleCall)cOwnedConditionAssignment_6_1.eContents().get(0);

		//// FIXME align with NameExpCS
		// // FIXME severity -> enum
		//
		//// Improve spec: result.log("message", severity) when condition
		// LogExpCS:
		//	'log' '(' ownedMessage=StringLiteralExpCS (',' ownedElement=ExpCS)? (',' severity=SeverityKindCS)? ')' ('when'
		//	ownedCondition=ExpCS)?;
		@Override public ParserRule getRule() { return rule; }

		//'log' '(' ownedMessage=StringLiteralExpCS (',' ownedElement=ExpCS)? (',' severity=SeverityKindCS)? ')' ('when'
		//ownedCondition=ExpCS)?
		public Group getGroup() { return cGroup; }

		//'log'
		public Keyword getLogKeyword_0() { return cLogKeyword_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//ownedMessage=StringLiteralExpCS
		public Assignment getOwnedMessageAssignment_2() { return cOwnedMessageAssignment_2; }

		//StringLiteralExpCS
		public RuleCall getOwnedMessageStringLiteralExpCSParserRuleCall_2_0() { return cOwnedMessageStringLiteralExpCSParserRuleCall_2_0; }

		//(',' ownedElement=ExpCS)?
		public Group getGroup_3() { return cGroup_3; }

		//','
		public Keyword getCommaKeyword_3_0() { return cCommaKeyword_3_0; }

		//ownedElement=ExpCS
		public Assignment getOwnedElementAssignment_3_1() { return cOwnedElementAssignment_3_1; }

		//ExpCS
		public RuleCall getOwnedElementExpCSParserRuleCall_3_1_0() { return cOwnedElementExpCSParserRuleCall_3_1_0; }

		//(',' severity=SeverityKindCS)?
		public Group getGroup_4() { return cGroup_4; }

		//','
		public Keyword getCommaKeyword_4_0() { return cCommaKeyword_4_0; }

		//severity=SeverityKindCS
		public Assignment getSeverityAssignment_4_1() { return cSeverityAssignment_4_1; }

		//SeverityKindCS
		public RuleCall getSeveritySeverityKindCSEnumRuleCall_4_1_0() { return cSeveritySeverityKindCSEnumRuleCall_4_1_0; }

		//')'
		public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }

		//('when' ownedCondition=ExpCS)?
		public Group getGroup_6() { return cGroup_6; }

		//'when'
		public Keyword getWhenKeyword_6_0() { return cWhenKeyword_6_0; }

		//ownedCondition=ExpCS
		public Assignment getOwnedConditionAssignment_6_1() { return cOwnedConditionAssignment_6_1; }

		//ExpCS
		public RuleCall getOwnedConditionExpCSParserRuleCall_6_1_0() { return cOwnedConditionExpCSParserRuleCall_6_1_0; }
	}

	public class RaiseExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.RaiseExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cRaiseKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Assignment cOwnedExceptionRefAssignment_1 = (Assignment)cGroup.eContents().get(1);
		private final RuleCall cOwnedExceptionRefTypeExpCSParserRuleCall_1_0 = (RuleCall)cOwnedExceptionRefAssignment_1.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2);
		private final Assignment cOwnedArgumentsAssignment_3 = (Assignment)cGroup.eContents().get(3);
		private final RuleCall cOwnedArgumentsExpCSParserRuleCall_3_0 = (RuleCall)cOwnedArgumentsAssignment_3.eContents().get(0);
		private final Group cGroup_4 = (Group)cGroup.eContents().get(4);
		private final Keyword cCommaKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0);
		private final Assignment cOwnedArgumentsAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1);
		private final RuleCall cOwnedArgumentsExpCSParserRuleCall_4_1_0 = (RuleCall)cOwnedArgumentsAssignment_4_1.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);

		//RaiseExpCS:
		//	'raise' ownedExceptionRef=TypeExpCS '(' ownedArguments+=ExpCS (',' ownedArguments+=ExpCS)* ')'
		//	// FIXME OMG: should support several arguments
		//;
		@Override public ParserRule getRule() { return rule; }

		//'raise' ownedExceptionRef=TypeExpCS '(' ownedArguments+=ExpCS (',' ownedArguments+=ExpCS)* ')'
		public Group getGroup() { return cGroup; }

		//'raise'
		public Keyword getRaiseKeyword_0() { return cRaiseKeyword_0; }

		//ownedExceptionRef=TypeExpCS
		public Assignment getOwnedExceptionRefAssignment_1() { return cOwnedExceptionRefAssignment_1; }

		//TypeExpCS
		public RuleCall getOwnedExceptionRefTypeExpCSParserRuleCall_1_0() { return cOwnedExceptionRefTypeExpCSParserRuleCall_1_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_2() { return cLeftParenthesisKeyword_2; }

		//ownedArguments+=ExpCS
		public Assignment getOwnedArgumentsAssignment_3() { return cOwnedArgumentsAssignment_3; }

		//ExpCS
		public RuleCall getOwnedArgumentsExpCSParserRuleCall_3_0() { return cOwnedArgumentsExpCSParserRuleCall_3_0; }

		//(',' ownedArguments+=ExpCS)*
		public Group getGroup_4() { return cGroup_4; }

		//','
		public Keyword getCommaKeyword_4_0() { return cCommaKeyword_4_0; }

		//ownedArguments+=ExpCS
		public Assignment getOwnedArgumentsAssignment_4_1() { return cOwnedArgumentsAssignment_4_1; }

		//ExpCS
		public RuleCall getOwnedArgumentsExpCSParserRuleCall_4_1_0() { return cOwnedArgumentsExpCSParserRuleCall_4_1_0; }

		//')'
		public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }
	}

	public class ReturnExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.ReturnExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cReturnKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Action cReturnExpCSAction_1 = (Action)cGroup.eContents().get(1);
		private final Assignment cOwnedValueAssignment_2 = (Assignment)cGroup.eContents().get(2);
		private final RuleCall cOwnedValueExpCSParserRuleCall_2_0 = (RuleCall)cOwnedValueAssignment_2.eContents().get(0);

		//ReturnExpCS:
		//	'return' {ReturnExpCS} ownedValue=ExpCS?;
		@Override public ParserRule getRule() { return rule; }

		//'return' {ReturnExpCS} ownedValue=ExpCS?
		public Group getGroup() { return cGroup; }

		//'return'
		public Keyword getReturnKeyword_0() { return cReturnKeyword_0; }

		//{ReturnExpCS}
		public Action getReturnExpCSAction_1() { return cReturnExpCSAction_1; }

		//ownedValue=ExpCS?
		public Assignment getOwnedValueAssignment_2() { return cOwnedValueAssignment_2; }

		//ExpCS
		public RuleCall getOwnedValueExpCSParserRuleCall_2_0() { return cOwnedValueExpCSParserRuleCall_2_0; }
	}

	public class StringLiteralElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.StringLiteral");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final RuleCall cSINGLE_QUOTED_STRINGTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
		private final RuleCall cDOUBLE_QUOTED_STRINGTerminalRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);

		//StringLiteral:
		//	SINGLE_QUOTED_STRING | DOUBLE_QUOTED_STRING;
		@Override public ParserRule getRule() { return rule; }

		//SINGLE_QUOTED_STRING | DOUBLE_QUOTED_STRING
		public Alternatives getAlternatives() { return cAlternatives; }

		//SINGLE_QUOTED_STRING
		public RuleCall getSINGLE_QUOTED_STRINGTerminalRuleCall_0() { return cSINGLE_QUOTED_STRINGTerminalRuleCall_0; }

		//DOUBLE_QUOTED_STRING
		public RuleCall getDOUBLE_QUOTED_STRINGTerminalRuleCall_1() { return cDOUBLE_QUOTED_STRINGTerminalRuleCall_1; }
	}

	public class SwitchExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.SwitchExpCS");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
		private final Assignment cIfSyntaxAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0);
		private final Keyword cIfSyntaxIfKeyword_0_0_0 = (Keyword)cIfSyntaxAssignment_0_0.eContents().get(0);
		private final Assignment cOwnedAltPartsAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
		private final RuleCall cOwnedAltPartsSwitchAltCSParserRuleCall_0_1_0 = (RuleCall)cOwnedAltPartsAssignment_0_1.eContents().get(0);
		private final Group cGroup_0_2 = (Group)cGroup_0.eContents().get(2);
		private final Keyword cElifKeyword_0_2_0 = (Keyword)cGroup_0_2.eContents().get(0);
		private final Assignment cOwnedAltPartsAssignment_0_2_1 = (Assignment)cGroup_0_2.eContents().get(1);
		private final RuleCall cOwnedAltPartsSwitchAltCSParserRuleCall_0_2_1_0 = (RuleCall)cOwnedAltPartsAssignment_0_2_1.eContents().get(0);
		private final Group cGroup_0_3 = (Group)cGroup_0.eContents().get(3);
		private final Keyword cElseKeyword_0_3_0 = (Keyword)cGroup_0_3.eContents().get(0);
		private final Assignment cOwnedElsePartAssignment_0_3_1 = (Assignment)cGroup_0_3.eContents().get(1);
		private final RuleCall cOwnedElsePartExpCSParserRuleCall_0_3_1_0 = (RuleCall)cOwnedElsePartAssignment_0_3_1.eContents().get(0);
		private final Keyword cEndifKeyword_0_4 = (Keyword)cGroup_0.eContents().get(4);
		private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
		private final Keyword cSwitchKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0);
		private final Group cGroup_1_1 = (Group)cGroup_1.eContents().get(1);
		private final Keyword cLeftParenthesisKeyword_1_1_0 = (Keyword)cGroup_1_1.eContents().get(0);
		private final Assignment cOwnedIteratorAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1);
		private final RuleCall cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_1_1_1_0 = (RuleCall)cOwnedIteratorAssignment_1_1_1.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_1_1_2 = (Keyword)cGroup_1_1.eContents().get(2);
		private final Keyword cLeftCurlyBracketKeyword_1_2 = (Keyword)cGroup_1.eContents().get(2);
		private final Group cGroup_1_3 = (Group)cGroup_1.eContents().get(3);
		private final Keyword cCaseKeyword_1_3_0 = (Keyword)cGroup_1_3.eContents().get(0);
		private final Assignment cOwnedAltPartsAssignment_1_3_1 = (Assignment)cGroup_1_3.eContents().get(1);
		private final RuleCall cOwnedAltPartsSwitchAltCSParserRuleCall_1_3_1_0 = (RuleCall)cOwnedAltPartsAssignment_1_3_1.eContents().get(0);
		private final Group cGroup_1_4 = (Group)cGroup_1.eContents().get(4);
		private final Keyword cElseKeyword_1_4_0 = (Keyword)cGroup_1_4.eContents().get(0);
		private final Assignment cOwnedElsePartAssignment_1_4_1 = (Assignment)cGroup_1_4.eContents().get(1);
		private final RuleCall cOwnedElsePartExpCSParserRuleCall_1_4_1_0 = (RuleCall)cOwnedElsePartAssignment_1_4_1.eContents().get(0);
		private final Keyword cRightCurlyBracketKeyword_1_5 = (Keyword)cGroup_1.eContents().get(5);

		//// FIXME OMG issue: list->swith(i) {...} syntax ?????
		// // FIXME SwitchExpCS should probably be a CallExp
		// SwitchExpCS:
		//	ifSyntax?='if' ownedAltParts+=SwitchAltCS ('elif' ownedAltParts+=SwitchAltCS)* ('else' ownedElsePart=ExpCS)? 'endif'?
		//	| 'switch' ('(' ownedIterator=VarDeclarationNoInitCS ')')? '{' ('case' ownedAltParts+=SwitchAltCS)+ ('else'
		//	ownedElsePart=ExpCS)? '}';
		@Override public ParserRule getRule() { return rule; }

		//ifSyntax?='if' ownedAltParts+=SwitchAltCS ('elif' ownedAltParts+=SwitchAltCS)* ('else' ownedElsePart=ExpCS)? 'endif'? |
		//'switch' ('(' ownedIterator=VarDeclarationNoInitCS ')')? '{' ('case' ownedAltParts+=SwitchAltCS)+ ('else'
		//ownedElsePart=ExpCS)? '}'
		public Alternatives getAlternatives() { return cAlternatives; }

		//ifSyntax?='if' ownedAltParts+=SwitchAltCS ('elif' ownedAltParts+=SwitchAltCS)* ('else' ownedElsePart=ExpCS)? 'endif'?
		public Group getGroup_0() { return cGroup_0; }

		//ifSyntax?='if'
		public Assignment getIfSyntaxAssignment_0_0() { return cIfSyntaxAssignment_0_0; }

		//'if'
		public Keyword getIfSyntaxIfKeyword_0_0_0() { return cIfSyntaxIfKeyword_0_0_0; }

		//ownedAltParts+=SwitchAltCS
		public Assignment getOwnedAltPartsAssignment_0_1() { return cOwnedAltPartsAssignment_0_1; }

		//SwitchAltCS
		public RuleCall getOwnedAltPartsSwitchAltCSParserRuleCall_0_1_0() { return cOwnedAltPartsSwitchAltCSParserRuleCall_0_1_0; }

		//('elif' ownedAltParts+=SwitchAltCS)*
		public Group getGroup_0_2() { return cGroup_0_2; }

		//'elif'
		public Keyword getElifKeyword_0_2_0() { return cElifKeyword_0_2_0; }

		//ownedAltParts+=SwitchAltCS
		public Assignment getOwnedAltPartsAssignment_0_2_1() { return cOwnedAltPartsAssignment_0_2_1; }

		//SwitchAltCS
		public RuleCall getOwnedAltPartsSwitchAltCSParserRuleCall_0_2_1_0() { return cOwnedAltPartsSwitchAltCSParserRuleCall_0_2_1_0; }

		//('else' ownedElsePart=ExpCS)?
		public Group getGroup_0_3() { return cGroup_0_3; }

		//'else'
		public Keyword getElseKeyword_0_3_0() { return cElseKeyword_0_3_0; }

		//ownedElsePart=ExpCS
		public Assignment getOwnedElsePartAssignment_0_3_1() { return cOwnedElsePartAssignment_0_3_1; }

		//ExpCS
		public RuleCall getOwnedElsePartExpCSParserRuleCall_0_3_1_0() { return cOwnedElsePartExpCSParserRuleCall_0_3_1_0; }

		//'endif'?
		public Keyword getEndifKeyword_0_4() { return cEndifKeyword_0_4; }

		//'switch' ('(' ownedIterator=VarDeclarationNoInitCS ')')? '{' ('case' ownedAltParts+=SwitchAltCS)+ ('else'
		//ownedElsePart=ExpCS)? '}'
		public Group getGroup_1() { return cGroup_1; }

		//'switch'
		public Keyword getSwitchKeyword_1_0() { return cSwitchKeyword_1_0; }

		//('(' ownedIterator=VarDeclarationNoInitCS ')')?
		public Group getGroup_1_1() { return cGroup_1_1; }

		//'('
		public Keyword getLeftParenthesisKeyword_1_1_0() { return cLeftParenthesisKeyword_1_1_0; }

		//ownedIterator=VarDeclarationNoInitCS
		public Assignment getOwnedIteratorAssignment_1_1_1() { return cOwnedIteratorAssignment_1_1_1; }

		//VarDeclarationNoInitCS
		public RuleCall getOwnedIteratorVarDeclarationNoInitCSParserRuleCall_1_1_1_0() { return cOwnedIteratorVarDeclarationNoInitCSParserRuleCall_1_1_1_0; }

		//')'
		public Keyword getRightParenthesisKeyword_1_1_2() { return cRightParenthesisKeyword_1_1_2; }

		//'{'
		public Keyword getLeftCurlyBracketKeyword_1_2() { return cLeftCurlyBracketKeyword_1_2; }

		//('case' ownedAltParts+=SwitchAltCS)+
		public Group getGroup_1_3() { return cGroup_1_3; }

		//'case'
		public Keyword getCaseKeyword_1_3_0() { return cCaseKeyword_1_3_0; }

		//ownedAltParts+=SwitchAltCS
		public Assignment getOwnedAltPartsAssignment_1_3_1() { return cOwnedAltPartsAssignment_1_3_1; }

		//SwitchAltCS
		public RuleCall getOwnedAltPartsSwitchAltCSParserRuleCall_1_3_1_0() { return cOwnedAltPartsSwitchAltCSParserRuleCall_1_3_1_0; }

		//('else' ownedElsePart=ExpCS)?
		public Group getGroup_1_4() { return cGroup_1_4; }

		//'else'
		public Keyword getElseKeyword_1_4_0() { return cElseKeyword_1_4_0; }

		//ownedElsePart=ExpCS
		public Assignment getOwnedElsePartAssignment_1_4_1() { return cOwnedElsePartAssignment_1_4_1; }

		//ExpCS
		public RuleCall getOwnedElsePartExpCSParserRuleCall_1_4_1_0() { return cOwnedElsePartExpCSParserRuleCall_1_4_1_0; }

		//'}'
		public Keyword getRightCurlyBracketKeyword_1_5() { return cRightCurlyBracketKeyword_1_5; }
	}

	public class SwitchAltCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.SwitchAltCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cLeftParenthesisKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Assignment cOwnedConditionAssignment_1 = (Assignment)cGroup.eContents().get(1);
		private final RuleCall cOwnedConditionExpCSParserRuleCall_1_0 = (RuleCall)cOwnedConditionAssignment_1.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2);
		private final Assignment cOwnedBodyAssignment_3 = (Assignment)cGroup.eContents().get(3);
		private final RuleCall cOwnedBodyExpCSParserRuleCall_3_0 = (RuleCall)cOwnedBodyAssignment_3.eContents().get(0);

		//SwitchAltCS:
		//	'(' ownedCondition=ExpCS ')' ownedBody=ExpCS;
		@Override public ParserRule getRule() { return rule; }

		//'(' ownedCondition=ExpCS ')' ownedBody=ExpCS
		public Group getGroup() { return cGroup; }

		//'('
		public Keyword getLeftParenthesisKeyword_0() { return cLeftParenthesisKeyword_0; }

		//ownedCondition=ExpCS
		public Assignment getOwnedConditionAssignment_1() { return cOwnedConditionAssignment_1; }

		//ExpCS
		public RuleCall getOwnedConditionExpCSParserRuleCall_1_0() { return cOwnedConditionExpCSParserRuleCall_1_0; }

		//')'
		public Keyword getRightParenthesisKeyword_2() { return cRightParenthesisKeyword_2; }

		//ownedBody=ExpCS
		public Assignment getOwnedBodyAssignment_3() { return cOwnedBodyAssignment_3; }

		//ExpCS
		public RuleCall getOwnedBodyExpCSParserRuleCall_3_0() { return cOwnedBodyExpCSParserRuleCall_3_0; }
	}

	public class TryExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.TryExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Action cTryExpCSAction_0 = (Action)cGroup.eContents().get(0);
		private final Keyword cTryKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2);
		private final Assignment cOwnedExpsAssignment_3 = (Assignment)cGroup.eContents().get(3);
		private final RuleCall cOwnedExpsExpCSParserRuleCall_3_0 = (RuleCall)cOwnedExpsAssignment_3.eContents().get(0);
		private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4);
		private final Assignment cOwnedCatchsAssignment_5 = (Assignment)cGroup.eContents().get(5);
		private final RuleCall cOwnedCatchsCatchExpCSParserRuleCall_5_0 = (RuleCall)cOwnedCatchsAssignment_5.eContents().get(0);

		//TryExpCS:
		//	{TryExpCS} 'try' '{' ownedExps+=ExpCS* '}' ownedCatchs+=CatchExpCS+
		//	// FIXME in the AS there should be at least one CatchExp
		//;
		@Override public ParserRule getRule() { return rule; }

		//{TryExpCS} 'try' '{' ownedExps+=ExpCS* '}' ownedCatchs+=CatchExpCS+
		public Group getGroup() { return cGroup; }

		//{TryExpCS}
		public Action getTryExpCSAction_0() { return cTryExpCSAction_0; }

		//'try'
		public Keyword getTryKeyword_1() { return cTryKeyword_1; }

		//'{'
		public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; }

		//ownedExps+=ExpCS*
		public Assignment getOwnedExpsAssignment_3() { return cOwnedExpsAssignment_3; }

		//ExpCS
		public RuleCall getOwnedExpsExpCSParserRuleCall_3_0() { return cOwnedExpsExpCSParserRuleCall_3_0; }

		//'}'
		public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; }

		//ownedCatchs+=CatchExpCS+
		public Assignment getOwnedCatchsAssignment_5() { return cOwnedCatchsAssignment_5; }

		//CatchExpCS
		public RuleCall getOwnedCatchsCatchExpCSParserRuleCall_5_0() { return cOwnedCatchsCatchExpCSParserRuleCall_5_0; }
	}

	public class VarDeclarationCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.VarDeclarationCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Assignment cNameAssignment_0 = (Assignment)cGroup.eContents().get(0);
		private final RuleCall cNameUnrestrictedNameParserRuleCall_0_0 = (RuleCall)cNameAssignment_0.eContents().get(0);
		private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
		private final Keyword cColonKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0);
		private final Assignment cOwnedTypeAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
		private final RuleCall cOwnedTypeTypeExpCSParserRuleCall_1_1_0 = (RuleCall)cOwnedTypeAssignment_1_1.eContents().get(0);
		private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
		private final Assignment cInitOpAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0);
		private final RuleCall cInitOpInitOpCSEnumRuleCall_2_0_0 = (RuleCall)cInitOpAssignment_2_0.eContents().get(0);
		private final Assignment cOwnedInitExpressionAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1);
		private final RuleCall cOwnedInitExpressionExpCSParserRuleCall_2_1_0 = (RuleCall)cOwnedInitExpressionAssignment_2_1.eContents().get(0);

		//// FIXME there should be additional disambiguation between NameExpCS and UnlinkExp
		//
		//// UnlinkExpCS returns essentialocl::NameExpCS:
		// VarDeclarationCS:
		//	name=UnrestrictedName (':' ownedType=TypeExpCS)? (initOp=InitOpCS ownedInitExpression=ExpCS)?;
		@Override public ParserRule getRule() { return rule; }

		//name=UnrestrictedName (':' ownedType=TypeExpCS)? (initOp=InitOpCS ownedInitExpression=ExpCS)?
		public Group getGroup() { return cGroup; }

		//name=UnrestrictedName
		public Assignment getNameAssignment_0() { return cNameAssignment_0; }

		//UnrestrictedName
		public RuleCall getNameUnrestrictedNameParserRuleCall_0_0() { return cNameUnrestrictedNameParserRuleCall_0_0; }

		//(':' ownedType=TypeExpCS)?
		public Group getGroup_1() { return cGroup_1; }

		//':'
		public Keyword getColonKeyword_1_0() { return cColonKeyword_1_0; }

		//ownedType=TypeExpCS
		public Assignment getOwnedTypeAssignment_1_1() { return cOwnedTypeAssignment_1_1; }

		//TypeExpCS
		public RuleCall getOwnedTypeTypeExpCSParserRuleCall_1_1_0() { return cOwnedTypeTypeExpCSParserRuleCall_1_1_0; }

		//(initOp=InitOpCS ownedInitExpression=ExpCS)?
		public Group getGroup_2() { return cGroup_2; }

		//initOp=InitOpCS
		public Assignment getInitOpAssignment_2_0() { return cInitOpAssignment_2_0; }

		//InitOpCS
		public RuleCall getInitOpInitOpCSEnumRuleCall_2_0_0() { return cInitOpInitOpCSEnumRuleCall_2_0_0; }

		//ownedInitExpression=ExpCS
		public Assignment getOwnedInitExpressionAssignment_2_1() { return cOwnedInitExpressionAssignment_2_1; }

		//ExpCS
		public RuleCall getOwnedInitExpressionExpCSParserRuleCall_2_1_0() { return cOwnedInitExpressionExpCSParserRuleCall_2_1_0; }
	}

	public class VarDeclarationNoInitCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.VarDeclarationNoInitCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Assignment cNameAssignment_0 = (Assignment)cGroup.eContents().get(0);
		private final RuleCall cNameUnrestrictedNameParserRuleCall_0_0 = (RuleCall)cNameAssignment_0.eContents().get(0);
		private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
		private final Keyword cColonKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0);
		private final Assignment cOwnedTypeAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
		private final RuleCall cOwnedTypeTypeExpCSParserRuleCall_1_1_0 = (RuleCall)cOwnedTypeAssignment_1_1.eContents().get(0);

		//VarDeclarationNoInitCS VarDeclarationCS:
		//	name=UnrestrictedName (':' ownedType=TypeExpCS)?;
		@Override public ParserRule getRule() { return rule; }

		//name=UnrestrictedName (':' ownedType=TypeExpCS)?
		public Group getGroup() { return cGroup; }

		//name=UnrestrictedName
		public Assignment getNameAssignment_0() { return cNameAssignment_0; }

		//UnrestrictedName
		public RuleCall getNameUnrestrictedNameParserRuleCall_0_0() { return cNameUnrestrictedNameParserRuleCall_0_0; }

		//(':' ownedType=TypeExpCS)?
		public Group getGroup_1() { return cGroup_1; }

		//':'
		public Keyword getColonKeyword_1_0() { return cColonKeyword_1_0; }

		//ownedType=TypeExpCS
		public Assignment getOwnedTypeAssignment_1_1() { return cOwnedTypeAssignment_1_1; }

		//TypeExpCS
		public RuleCall getOwnedTypeTypeExpCSParserRuleCall_1_1_0() { return cOwnedTypeTypeExpCSParserRuleCall_1_1_0; }
	}

	public class VarsInitializationCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.VarsInitializationCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cVarKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Assignment cOwnedVarDeclarationsAssignment_1 = (Assignment)cGroup.eContents().get(1);
		private final RuleCall cOwnedVarDeclarationsVarDeclarationCSParserRuleCall_1_0 = (RuleCall)cOwnedVarDeclarationsAssignment_1.eContents().get(0);
		private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
		private final Keyword cCommaKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0);
		private final Assignment cOwnedVarDeclarationsAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1);
		private final RuleCall cOwnedVarDeclarationsVarDeclarationCSParserRuleCall_2_1_0 = (RuleCall)cOwnedVarDeclarationsAssignment_2_1.eContents().get(0);

		//VarsInitializationCS:
		//	'var' ownedVarDeclarations+=VarDeclarationCS (',' ownedVarDeclarations+=VarDeclarationCS)*;
		@Override public ParserRule getRule() { return rule; }

		//'var' ownedVarDeclarations+=VarDeclarationCS (',' ownedVarDeclarations+=VarDeclarationCS)*
		public Group getGroup() { return cGroup; }

		//'var'
		public Keyword getVarKeyword_0() { return cVarKeyword_0; }

		//ownedVarDeclarations+=VarDeclarationCS
		public Assignment getOwnedVarDeclarationsAssignment_1() { return cOwnedVarDeclarationsAssignment_1; }

		//VarDeclarationCS
		public RuleCall getOwnedVarDeclarationsVarDeclarationCSParserRuleCall_1_0() { return cOwnedVarDeclarationsVarDeclarationCSParserRuleCall_1_0; }

		//(',' ownedVarDeclarations+=VarDeclarationCS)*
		public Group getGroup_2() { return cGroup_2; }

		//','
		public Keyword getCommaKeyword_2_0() { return cCommaKeyword_2_0; }

		//ownedVarDeclarations+=VarDeclarationCS
		public Assignment getOwnedVarDeclarationsAssignment_2_1() { return cOwnedVarDeclarationsAssignment_2_1; }

		//VarDeclarationCS
		public RuleCall getOwnedVarDeclarationsVarDeclarationCSParserRuleCall_2_1_0() { return cOwnedVarDeclarationsVarDeclarationCSParserRuleCall_2_1_0; }
	}

	public class WhileExpCSElements extends AbstractParserRuleElementFinder {
		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.WhileExpCS");
		private final Group cGroup = (Group)rule.eContents().get(1);
		private final Keyword cWhileKeyword_0 = (Keyword)cGroup.eContents().get(0);
		private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
		private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
		private final Assignment cOwnedResultVarAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0);
		private final RuleCall cOwnedResultVarVarDeclarationCSParserRuleCall_2_0_0 = (RuleCall)cOwnedResultVarAssignment_2_0.eContents().get(0);
		private final Keyword cSemicolonKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1);
		private final Assignment cOwnedConditionAssignment_3 = (Assignment)cGroup.eContents().get(3);
		private final RuleCall cOwnedConditionExpCSParserRuleCall_3_0 = (RuleCall)cOwnedConditionAssignment_3.eContents().get(0);
		private final Keyword cRightParenthesisKeyword_4 = (Keyword)cGroup.eContents().get(4);
		private final Keyword cLeftCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5);
		private final Assignment cOwnedExpsAssignment_6 = (Assignment)cGroup.eContents().get(6);
		private final RuleCall cOwnedExpsExpressionStatementCSParserRuleCall_6_0 = (RuleCall)cOwnedExpsAssignment_6.eContents().get(0);
		private final Keyword cRightCurlyBracketKeyword_7 = (Keyword)cGroup.eContents().get(7);

		//WhileExpCS:
		//	'while' '(' (ownedResultVar=VarDeclarationCS ';')? ownedCondition=ExpCS ')' '{' ownedExps+=ExpressionStatementCS*
		//	'}';
		@Override public ParserRule getRule() { return rule; }

		//'while' '(' (ownedResultVar=VarDeclarationCS ';')? ownedCondition=ExpCS ')' '{' ownedExps+=ExpressionStatementCS* '}'
		public Group getGroup() { return cGroup; }

		//'while'
		public Keyword getWhileKeyword_0() { return cWhileKeyword_0; }

		//'('
		public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }

		//(ownedResultVar=VarDeclarationCS ';')?
		public Group getGroup_2() { return cGroup_2; }

		//ownedResultVar=VarDeclarationCS
		public Assignment getOwnedResultVarAssignment_2_0() { return cOwnedResultVarAssignment_2_0; }

		//VarDeclarationCS
		public RuleCall getOwnedResultVarVarDeclarationCSParserRuleCall_2_0_0() { return cOwnedResultVarVarDeclarationCSParserRuleCall_2_0_0; }

		//';'
		public Keyword getSemicolonKeyword_2_1() { return cSemicolonKeyword_2_1; }

		//ownedCondition=ExpCS
		public Assignment getOwnedConditionAssignment_3() { return cOwnedConditionAssignment_3; }

		//ExpCS
		public RuleCall getOwnedConditionExpCSParserRuleCall_3_0() { return cOwnedConditionExpCSParserRuleCall_3_0; }

		//')'
		public Keyword getRightParenthesisKeyword_4() { return cRightParenthesisKeyword_4; }

		//'{'
		public Keyword getLeftCurlyBracketKeyword_5() { return cLeftCurlyBracketKeyword_5; }

		//ownedExps+=ExpressionStatementCS*
		public Assignment getOwnedExpsAssignment_6() { return cOwnedExpsAssignment_6; }

		//ExpressionStatementCS
		public RuleCall getOwnedExpsExpressionStatementCSParserRuleCall_6_0() { return cOwnedExpsExpressionStatementCSParserRuleCall_6_0; }

		//'}'
		public Keyword getRightCurlyBracketKeyword_7() { return cRightCurlyBracketKeyword_7; }
	}


	public class SeverityKindCSElements extends AbstractEnumRuleElementFinder {
		private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.SeverityKindCS");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final EnumLiteralDeclaration cErrorEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0);
		private final Keyword cErrorErrorKeyword_0_0 = (Keyword)cErrorEnumLiteralDeclaration_0.eContents().get(0);
		private final EnumLiteralDeclaration cWarningEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1);
		private final Keyword cWarningWarningKeyword_1_0 = (Keyword)cWarningEnumLiteralDeclaration_1.eContents().get(0);
		private final EnumLiteralDeclaration cFatalEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2);
		private final Keyword cFatalFatalKeyword_2_0 = (Keyword)cFatalEnumLiteralDeclaration_2.eContents().get(0);

		//enum SeverityKindCS:
		//	error | warning | fatal;
		public EnumRule getRule() { return rule; }

		//error | warning | fatal
		public Alternatives getAlternatives() { return cAlternatives; }

		//error
		public EnumLiteralDeclaration getErrorEnumLiteralDeclaration_0() { return cErrorEnumLiteralDeclaration_0; }

		//'error'
		public Keyword getErrorErrorKeyword_0_0() { return cErrorErrorKeyword_0_0; }

		//warning
		public EnumLiteralDeclaration getWarningEnumLiteralDeclaration_1() { return cWarningEnumLiteralDeclaration_1; }

		//'warning'
		public Keyword getWarningWarningKeyword_1_0() { return cWarningWarningKeyword_1_0; }

		//fatal
		public EnumLiteralDeclaration getFatalEnumLiteralDeclaration_2() { return cFatalEnumLiteralDeclaration_2; }

		//'fatal'
		public Keyword getFatalFatalKeyword_2_0() { return cFatalFatalKeyword_2_0; }
	}

	public class InitOpCSElements extends AbstractEnumRuleElementFinder {
		private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.InitOpCS");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final EnumLiteralDeclaration cEqualsEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0);
		private final Keyword cEqualsEqualsSignKeyword_0_0 = (Keyword)cEqualsEnumLiteralDeclaration_0.eContents().get(0);
		private final EnumLiteralDeclaration cColonEqualsEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1);
		private final Keyword cColonEqualsColonEqualsSignKeyword_1_0 = (Keyword)cColonEqualsEnumLiteralDeclaration_1.eContents().get(0);
		private final EnumLiteralDeclaration cColonColonEqualsEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2);
		private final Keyword cColonColonEqualsColonColonEqualsSignKeyword_2_0 = (Keyword)cColonColonEqualsEnumLiteralDeclaration_2.eContents().get(0);

		//enum InitOpCS:
		//	Equals='=' | ColonEquals=':=' | ColonColonEquals='::=';
		public EnumRule getRule() { return rule; }

		//Equals='=' | ColonEquals=':=' | ColonColonEquals='::='
		public Alternatives getAlternatives() { return cAlternatives; }

		//Equals='='
		public EnumLiteralDeclaration getEqualsEnumLiteralDeclaration_0() { return cEqualsEnumLiteralDeclaration_0; }

		//'='
		public Keyword getEqualsEqualsSignKeyword_0_0() { return cEqualsEqualsSignKeyword_0_0; }

		//ColonEquals=':='
		public EnumLiteralDeclaration getColonEqualsEnumLiteralDeclaration_1() { return cColonEqualsEnumLiteralDeclaration_1; }

		//':='
		public Keyword getColonEqualsColonEqualsSignKeyword_1_0() { return cColonEqualsColonEqualsSignKeyword_1_0; }

		//ColonColonEquals='::='
		public EnumLiteralDeclaration getColonColonEqualsEnumLiteralDeclaration_2() { return cColonColonEqualsEnumLiteralDeclaration_2; }

		//'::='
		public Keyword getColonColonEqualsColonColonEqualsSignKeyword_2_0() { return cColonColonEqualsColonColonEqualsSignKeyword_2_0; }
	}

	public class AssignOpCSElements extends AbstractEnumRuleElementFinder {
		private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL.AssignOpCS");
		private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
		private final EnumLiteralDeclaration cSingleEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0);
		private final Keyword cSingleColonEqualsSignKeyword_0_0 = (Keyword)cSingleEnumLiteralDeclaration_0.eContents().get(0);
		private final EnumLiteralDeclaration cMultiWithResetEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1);
		private final Keyword cMultiWithResetColonColonEqualsSignKeyword_1_0 = (Keyword)cMultiWithResetEnumLiteralDeclaration_1.eContents().get(0);
		private final EnumLiteralDeclaration cMultiWithoutResetEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2);
		private final Keyword cMultiWithoutResetPlusSignEqualsSignKeyword_2_0 = (Keyword)cMultiWithoutResetEnumLiteralDeclaration_2.eContents().get(0);

		//enum AssignOpCS:
		//	Single=':=' | MultiWithReset='::=' | MultiWithoutReset='+=';
		public EnumRule getRule() { return rule; }

		//Single=':=' | MultiWithReset='::=' | MultiWithoutReset='+='
		public Alternatives getAlternatives() { return cAlternatives; }

		//Single=':='
		public EnumLiteralDeclaration getSingleEnumLiteralDeclaration_0() { return cSingleEnumLiteralDeclaration_0; }

		//':='
		public Keyword getSingleColonEqualsSignKeyword_0_0() { return cSingleColonEqualsSignKeyword_0_0; }

		//MultiWithReset='::='
		public EnumLiteralDeclaration getMultiWithResetEnumLiteralDeclaration_1() { return cMultiWithResetEnumLiteralDeclaration_1; }

		//'::='
		public Keyword getMultiWithResetColonColonEqualsSignKeyword_1_0() { return cMultiWithResetColonColonEqualsSignKeyword_1_0; }

		//MultiWithoutReset='+='
		public EnumLiteralDeclaration getMultiWithoutResetEnumLiteralDeclaration_2() { return cMultiWithoutResetEnumLiteralDeclaration_2; }

		//'+='
		public Keyword getMultiWithoutResetPlusSignEqualsSignKeyword_2_0() { return cMultiWithoutResetPlusSignEqualsSignKeyword_2_0; }
	}

	private final GrammmarCSElements pGrammmarCS;
	private final SeverityKindCSElements eSeverityKindCS;
	private final InitOpCSElements eInitOpCS;
	private final AssignOpCSElements eAssignOpCS;
	private final ImperativeOCLExpCSElements pImperativeOCLExpCS;
	private final TypeLiteralCSElements pTypeLiteralCS;
	private final ListTypeCSElements pListTypeCS;
	private final DictTypeCSElements pDictTypeCS;
	private final PrimaryExpCSElements pPrimaryExpCS;
	private final ImperativeExpCSElements pImperativeExpCS;
	private final AssertExpCSElements pAssertExpCS;
	private final AssignExpCSElements pAssignExpCS;
	private final BreakExpCSElements pBreakExpCS;
	private final CatchExpCSElements pCatchExpCS;
	private final ComputeExpCSElements pComputeExpCS;
	private final ContinueExpCSElements pContinueExpCS;
	private final DictLiteralExpCSElements pDictLiteralExpCS;
	private final DictLiteralPartCSElements pDictLiteralPartCS;
	private final ExpressionBlockCSElements pExpressionBlockCS;
	private final ExpressionStatementCSElements pExpressionStatementCS;
	private final ExtentRefCSElements pExtentRefCS;
	private final ForExpCSElements pForExpCS;
	private final ImperativeIterateExpCSElements pImperativeIterateExpCS;
	private final InstantiationExpCSElements pInstantiationExpCS;
	private final ListLiteralExpCSElements pListLiteralExpCS;
	private final LogExpCSElements pLogExpCS;
	private final RaiseExpCSElements pRaiseExpCS;
	private final ReturnExpCSElements pReturnExpCS;
	private final StringLiteralElements pStringLiteral;
	private final SwitchExpCSElements pSwitchExpCS;
	private final SwitchAltCSElements pSwitchAltCS;
	private final TryExpCSElements pTryExpCS;
	private final VarDeclarationCSElements pVarDeclarationCS;
	private final VarDeclarationNoInitCSElements pVarDeclarationNoInitCS;
	private final VarsInitializationCSElements pVarsInitializationCS;
	private final WhileExpCSElements pWhileExpCS;

	private final Grammar grammar;

	private final EssentialOCLGrammarAccess gaEssentialOCL;

	private final BaseGrammarAccess gaBase;

	@Inject
	public ImperativeOCLGrammarAccess(GrammarProvider grammarProvider,
		EssentialOCLGrammarAccess gaEssentialOCL,
		BaseGrammarAccess gaBase) {
		this.grammar = internalFindGrammar(grammarProvider);
		this.gaEssentialOCL = gaEssentialOCL;
		this.gaBase = gaBase;
		this.pGrammmarCS = new GrammmarCSElements();
		this.eSeverityKindCS = new SeverityKindCSElements();
		this.eInitOpCS = new InitOpCSElements();
		this.eAssignOpCS = new AssignOpCSElements();
		this.pImperativeOCLExpCS = new ImperativeOCLExpCSElements();
		this.pTypeLiteralCS = new TypeLiteralCSElements();
		this.pListTypeCS = new ListTypeCSElements();
		this.pDictTypeCS = new DictTypeCSElements();
		this.pPrimaryExpCS = new PrimaryExpCSElements();
		this.pImperativeExpCS = new ImperativeExpCSElements();
		this.pAssertExpCS = new AssertExpCSElements();
		this.pAssignExpCS = new AssignExpCSElements();
		this.pBreakExpCS = new BreakExpCSElements();
		this.pCatchExpCS = new CatchExpCSElements();
		this.pComputeExpCS = new ComputeExpCSElements();
		this.pContinueExpCS = new ContinueExpCSElements();
		this.pDictLiteralExpCS = new DictLiteralExpCSElements();
		this.pDictLiteralPartCS = new DictLiteralPartCSElements();
		this.pExpressionBlockCS = new ExpressionBlockCSElements();
		this.pExpressionStatementCS = new ExpressionStatementCSElements();
		this.pExtentRefCS = new ExtentRefCSElements();
		this.pForExpCS = new ForExpCSElements();
		this.pImperativeIterateExpCS = new ImperativeIterateExpCSElements();
		this.pInstantiationExpCS = new InstantiationExpCSElements();
		this.pListLiteralExpCS = new ListLiteralExpCSElements();
		this.pLogExpCS = new LogExpCSElements();
		this.pRaiseExpCS = new RaiseExpCSElements();
		this.pReturnExpCS = new ReturnExpCSElements();
		this.pStringLiteral = new StringLiteralElements();
		this.pSwitchExpCS = new SwitchExpCSElements();
		this.pSwitchAltCS = new SwitchAltCSElements();
		this.pTryExpCS = new TryExpCSElements();
		this.pVarDeclarationCS = new VarDeclarationCSElements();
		this.pVarDeclarationNoInitCS = new VarDeclarationNoInitCSElements();
		this.pVarsInitializationCS = new VarsInitializationCSElements();
		this.pWhileExpCS = new WhileExpCSElements();
	}

	protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
		Grammar grammar = grammarProvider.getGrammar(this);
		while (grammar != null) {
			if ("org.eclipse.qvto.examples.xtext.imperativeocl.ImperativeOCL".equals(grammar.getName())) {
				return grammar;
			}
			List<Grammar> grammars = grammar.getUsedGrammars();
			if (!grammars.isEmpty()) {
				grammar = grammars.iterator().next();
			} else {
				return null;
			}
		}
		return grammar;
	}

	@Override
	public Grammar getGrammar() {
		return grammar;
	}


	public EssentialOCLGrammarAccess getEssentialOCLGrammarAccess() {
		return gaEssentialOCL;
	}

	public BaseGrammarAccess getBaseGrammarAccess() {
		return gaBase;
	}


	//GrammmarCS essentialocl::ExpCS:
	//	ImperativeOCLExpCS;
	public GrammmarCSElements getGrammmarCSAccess() {
		return pGrammmarCS;
	}

	public ParserRule getGrammmarCSRule() {
		return getGrammmarCSAccess().getRule();
	}

	//enum SeverityKindCS:
	//	error | warning | fatal;
	public SeverityKindCSElements getSeverityKindCSAccess() {
		return eSeverityKindCS;
	}

	public EnumRule getSeverityKindCSRule() {
		return getSeverityKindCSAccess().getRule();
	}

	//enum InitOpCS:
	//	Equals='=' | ColonEquals=':=' | ColonColonEquals='::=';
	public InitOpCSElements getInitOpCSAccess() {
		return eInitOpCS;
	}

	public EnumRule getInitOpCSRule() {
		return getInitOpCSAccess().getRule();
	}

	//enum AssignOpCS:
	//	Single=':=' | MultiWithReset='::=' | MultiWithoutReset='+=';
	public AssignOpCSElements getAssignOpCSAccess() {
		return eAssignOpCS;
	}

	public EnumRule getAssignOpCSRule() {
		return getAssignOpCSAccess().getRule();
	}

	////ImperativeOCLReservedKeyword:
	// //	'default'
	// //	| 'elif'
	// //	| RESOLVE_KIND
	// //	| RESOLVE_IN_KIND;
	// //
	//
	////ImperativeOCLPrefixOperator:
	// //	'#' | '##' | '*';
	// //
	// //ImperativeOCLInfixOperator:
	//
	////	ASSIGN_OP | 'default' | '==';
	// //
	// //ImperativeOCLNavigationOperator:
	// //	'!->';
	// //PrefixOperator:
	//
	////	EssentialOCLPrefixOperator | QVToPrefixOperator;
	// //
	// //InfixOperator:
	//
	////	EssentialOCLInfixOperator | QVToInfixOperator;
	// //
	// //NavigationOperator:
	//
	////	EssentialOCLNavigationOperator | QVToNavigationOperator;
	// ImperativeOCLExpCS essentialocl::ExpCS:
	//	ExpCS;
	public ImperativeOCLExpCSElements getImperativeOCLExpCSAccess() {
		return pImperativeOCLExpCS;
	}

	public ParserRule getImperativeOCLExpCSRule() {
		return getImperativeOCLExpCSAccess().getRule();
	}

	//// ********* ImperativeOCL Types *********
	// // TypeLiteralCS redefined to include the new List and Dict types
	//
	//// FIXME refactor its definition in EssentialOCL to allow extension
	// TypeLiteralCS base::TypedRefCS:
	//	PrimitiveTypeCS | CollectionTypeCS | MapTypeCS | TupleTypeCS | ListTypeCS | DictTypeCS;
	public TypeLiteralCSElements getTypeLiteralCSAccess() {
		return pTypeLiteralCS;
	}

	public ParserRule getTypeLiteralCSRule() {
		return getTypeLiteralCSAccess().getRule();
	}

	//ListTypeCS:
	//	'List' '(' ownedTypeRef=TypeExpCS ')';
	public ListTypeCSElements getListTypeCSAccess() {
		return pListTypeCS;
	}

	public ParserRule getListTypeCSRule() {
		return getListTypeCSAccess().getRule();
	}

	//DictTypeCS:
	//	'Dict' '(' ownedKeyTypeRef=TypeExpCS ',' ownedValueTypeRef=TypeExpCS ')';
	public DictTypeCSElements getDictTypeCSAccess() {
		return pDictTypeCS;
	}

	public ParserRule getDictTypeCSRule() {
		return getDictTypeCSAccess().getRule();
	}

	//// Typedef is deprecated
	// // ********* ImperativeOCL Expressions *********
	//
	//// PrimaryExpCS redefined to include the new List and Dict literal expressions
	//
	//// FIXME refactor its definition in EssentialOCL to allow extension
	// PrimaryExpCS essentialocl::ExpCS:
	//	NestedExpCS | IfExpCS | SelfExpCS | PrimitiveLiteralExpCS | TupleLiteralExpCS | MapLiteralExpCS |
	//	CollectionLiteralExpCS | LambdaLiteralExpCS | ImperativeExpCS | NameExpCS;
	public PrimaryExpCSElements getPrimaryExpCSAccess() {
		return pPrimaryExpCS;
	}

	public ParserRule getPrimaryExpCSRule() {
		return getPrimaryExpCSAccess().getRule();
	}

	//ImperativeExpCS essentialocl::ExpCS:
	//	ExpressionBlockCS | AssertExpCS | BreakExpCS | ContinueExpCS | InstantiationExpCS | LogExpCS | RaiseExpCS |
	//	VarsInitializationCS | ListLiteralExpCS | DictLiteralExpCS | TypeLiteralExpCS | ReturnExpCS | ComputeExpCS | ForExpCS
	//	| WhileExpCS | ImperativeIterateExpCS | SwitchExpCS | AssignExpCS | TryExpCS;
	public ImperativeExpCSElements getImperativeExpCSAccess() {
		return pImperativeExpCS;
	}

	public ParserRule getImperativeExpCSRule() {
		return getImperativeExpCSAccess().getRule();
	}

	//AssertExpCS:
	//	'assert' severity=SeverityKindCS? ownedAssertion=ExpCS ('with' ownedLog=LogExpCS)?;
	public AssertExpCSElements getAssertExpCSAccess() {
		return pAssertExpCS;
	}

	public ParserRule getAssertExpCSRule() {
		return getAssertExpCSAccess().getRule();
	}

	//AssignExpCS:
	//	ownedLeft=NameExpCS assignOp=AssignOpCS ownedValue=ExpCS ('default' ownedDefault=ExpCS)?;
	public AssignExpCSElements getAssignExpCSAccess() {
		return pAssignExpCS;
	}

	public ParserRule getAssignExpCSRule() {
		return getAssignExpCSAccess().getRule();
	}

	//BreakExpCS:
	//	{BreakExpCS} 'break';
	public BreakExpCSElements getBreakExpCSAccess() {
		return pBreakExpCS;
	}

	public ParserRule getBreakExpCSRule() {
		return getBreakExpCSAccess().getRule();
	}

	//CatchExpCS:
	//	'except' '(' (varName=UnrestrictedName ':')? ownedExceptionRefs+=TypeExpCS (',' ownedExceptionRefs+=TypeExpCS)* ')'
	//	'{' ownedExps+=ExpCS* '}';
	public CatchExpCSElements getCatchExpCSAccess() {
		return pCatchExpCS;
	}

	public ParserRule getCatchExpCSRule() {
		return getCatchExpCSAccess().getRule();
	}

	//ComputeExpCS:
	//	'compute' '(' ownedResultVar=VarDeclarationCS ')' '{' ownedExps+=ExpressionStatementCS '}';
	public ComputeExpCSElements getComputeExpCSAccess() {
		return pComputeExpCS;
	}

	public ParserRule getComputeExpCSRule() {
		return getComputeExpCSAccess().getRule();
	}

	//ContinueExpCS:
	//	{ContinueExpCS} 'continue';
	public ContinueExpCSElements getContinueExpCSAccess() {
		return pContinueExpCS;
	}

	public ParserRule getContinueExpCSRule() {
		return getContinueExpCSAccess().getRule();
	}

	//DictLiteralExpCS:
	//	'Dict' '{' {DictLiteralExpCS} (ownedParts+=DictLiteralPartCS (',' ownedParts+=DictLiteralPartCS)*)? '}';
	public DictLiteralExpCSElements getDictLiteralExpCSAccess() {
		return pDictLiteralExpCS;
	}

	public ParserRule getDictLiteralExpCSRule() {
		return getDictLiteralExpCSAccess().getRule();
	}

	//DictLiteralPartCS:
	//	ownedKey=PrimitiveLiteralExpCS '=' ownedValue=ExpCS;
	public DictLiteralPartCSElements getDictLiteralPartCSAccess() {
		return pDictLiteralPartCS;
	}

	public ParserRule getDictLiteralPartCSRule() {
		return getDictLiteralPartCSAccess().getRule();
	}

	//ExpressionBlockCS:
	//	{ExpressionBlockCS} 'do'? '{' ownedExps+=ExpressionStatementCS* '}';
	public ExpressionBlockCSElements getExpressionBlockCSAccess() {
		return pExpressionBlockCS;
	}

	public ParserRule getExpressionBlockCSRule() {
		return getExpressionBlockCSAccess().getRule();
	}

	//ExpressionStatementCS essentialocl::ExpCS:
	//	ExpCS ';'?;
	public ExpressionStatementCSElements getExpressionStatementCSAccess() {
		return pExpressionStatementCS;
	}

	public ParserRule getExpressionStatementCSRule() {
		return getExpressionStatementCSAccess().getRule();
	}

	//ExtentRefCS:
	//	ownedPathName=PathNameCS;
	public ExtentRefCSElements getExtentRefCSAccess() {
		return pExtentRefCS;
	}

	public ParserRule getExtentRefCSRule() {
		return getExtentRefCSAccess().getRule();
	}

	//// FIXME align with NameExpCS
	// ForExpCS:
	//	('forEach' | isOne?='forOne') '(' (ownedTarget=VarDeclarationCS ';')? ownedIterator=VarDeclarationNoInitCS ('|'
	//	ownedCondition=ExpCS)? ')' ownedBody=ExpCS;
	public ForExpCSElements getForExpCSAccess() {
		return pForExpCS;
	}

	public ParserRule getForExpCSRule() {
		return getForExpCSAccess().getRule();
	}

	//// FIXME align with NameExpCS
	// ImperativeIterateExpCS:
	//	name='xcollect' '(' (ownedIterator=VarDeclarationNoInitCS '|')? ownedBody=ExpCS ')' | name=('xselect' | 'xselectOne')
	//	'(' (ownedIterator=VarDeclarationNoInitCS '|')? ownedCondition=ExpCS ')' | name=('xcollectselect' |
	//	'xcollectselectOne') '(' (ownedIterator=VarDeclarationNoInitCS ';')? ownedTarget=VarDeclarationCS ':='
	//	ownedBody=ExpCS '|' ownedCondition=ExpCS ')';
	public ImperativeIterateExpCSElements getImperativeIterateExpCSAccess() {
		return pImperativeIterateExpCS;
	}

	public ParserRule getImperativeIterateExpCSRule() {
		return getImperativeIterateExpCSAccess().getRule();
	}

	//// FIXME if a new parameter can specify modelExtent, then it should probably belong to QVTOperational package rather than ImperativeOCL
	//
	//InstantiationExpCS:
	//	'new' ownedClassRef=TypeExpCS ('@' ownedExtentRef=TypeNameExpCS)? '(' (ownedArguments+=ExpCS (','
	//	ownedArguments+=ExpCS)*)? ')';
	public InstantiationExpCSElements getInstantiationExpCSAccess() {
		return pInstantiationExpCS;
	}

	public ParserRule getInstantiationExpCSRule() {
		return getInstantiationExpCSAccess().getRule();
	}

	//ListLiteralExpCS:
	//	'List' '{' {ListLiteralExpCS} (ownedParts+=CollectionLiteralPartCS (',' ownedParts+=CollectionLiteralPartCS)*)? '}';
	public ListLiteralExpCSElements getListLiteralExpCSAccess() {
		return pListLiteralExpCS;
	}

	public ParserRule getListLiteralExpCSRule() {
		return getListLiteralExpCSAccess().getRule();
	}

	//// FIXME align with NameExpCS
	// // FIXME severity -> enum
	//
	//// Improve spec: result.log("message", severity) when condition
	// LogExpCS:
	//	'log' '(' ownedMessage=StringLiteralExpCS (',' ownedElement=ExpCS)? (',' severity=SeverityKindCS)? ')' ('when'
	//	ownedCondition=ExpCS)?;
	public LogExpCSElements getLogExpCSAccess() {
		return pLogExpCS;
	}

	public ParserRule getLogExpCSRule() {
		return getLogExpCSAccess().getRule();
	}

	//RaiseExpCS:
	//	'raise' ownedExceptionRef=TypeExpCS '(' ownedArguments+=ExpCS (',' ownedArguments+=ExpCS)* ')'
	//	// FIXME OMG: should support several arguments
	//;
	public RaiseExpCSElements getRaiseExpCSAccess() {
		return pRaiseExpCS;
	}

	public ParserRule getRaiseExpCSRule() {
		return getRaiseExpCSAccess().getRule();
	}

	//ReturnExpCS:
	//	'return' {ReturnExpCS} ownedValue=ExpCS?;
	public ReturnExpCSElements getReturnExpCSAccess() {
		return pReturnExpCS;
	}

	public ParserRule getReturnExpCSRule() {
		return getReturnExpCSAccess().getRule();
	}

	//StringLiteral:
	//	SINGLE_QUOTED_STRING | DOUBLE_QUOTED_STRING;
	public StringLiteralElements getStringLiteralAccess() {
		return pStringLiteral;
	}

	public ParserRule getStringLiteralRule() {
		return getStringLiteralAccess().getRule();
	}

	//// FIXME OMG issue: list->swith(i) {...} syntax ?????
	// // FIXME SwitchExpCS should probably be a CallExp
	// SwitchExpCS:
	//	ifSyntax?='if' ownedAltParts+=SwitchAltCS ('elif' ownedAltParts+=SwitchAltCS)* ('else' ownedElsePart=ExpCS)? 'endif'?
	//	| 'switch' ('(' ownedIterator=VarDeclarationNoInitCS ')')? '{' ('case' ownedAltParts+=SwitchAltCS)+ ('else'
	//	ownedElsePart=ExpCS)? '}';
	public SwitchExpCSElements getSwitchExpCSAccess() {
		return pSwitchExpCS;
	}

	public ParserRule getSwitchExpCSRule() {
		return getSwitchExpCSAccess().getRule();
	}

	//SwitchAltCS:
	//	'(' ownedCondition=ExpCS ')' ownedBody=ExpCS;
	public SwitchAltCSElements getSwitchAltCSAccess() {
		return pSwitchAltCS;
	}

	public ParserRule getSwitchAltCSRule() {
		return getSwitchAltCSAccess().getRule();
	}

	//TryExpCS:
	//	{TryExpCS} 'try' '{' ownedExps+=ExpCS* '}' ownedCatchs+=CatchExpCS+
	//	// FIXME in the AS there should be at least one CatchExp
	//;
	public TryExpCSElements getTryExpCSAccess() {
		return pTryExpCS;
	}

	public ParserRule getTryExpCSRule() {
		return getTryExpCSAccess().getRule();
	}

	//// FIXME there should be additional disambiguation between NameExpCS and UnlinkExp
	//
	//// UnlinkExpCS returns essentialocl::NameExpCS:
	// VarDeclarationCS:
	//	name=UnrestrictedName (':' ownedType=TypeExpCS)? (initOp=InitOpCS ownedInitExpression=ExpCS)?;
	public VarDeclarationCSElements getVarDeclarationCSAccess() {
		return pVarDeclarationCS;
	}

	public ParserRule getVarDeclarationCSRule() {
		return getVarDeclarationCSAccess().getRule();
	}

	//VarDeclarationNoInitCS VarDeclarationCS:
	//	name=UnrestrictedName (':' ownedType=TypeExpCS)?;
	public VarDeclarationNoInitCSElements getVarDeclarationNoInitCSAccess() {
		return pVarDeclarationNoInitCS;
	}

	public ParserRule getVarDeclarationNoInitCSRule() {
		return getVarDeclarationNoInitCSAccess().getRule();
	}

	//VarsInitializationCS:
	//	'var' ownedVarDeclarations+=VarDeclarationCS (',' ownedVarDeclarations+=VarDeclarationCS)*;
	public VarsInitializationCSElements getVarsInitializationCSAccess() {
		return pVarsInitializationCS;
	}

	public ParserRule getVarsInitializationCSRule() {
		return getVarsInitializationCSAccess().getRule();
	}

	//WhileExpCS:
	//	'while' '(' (ownedResultVar=VarDeclarationCS ';')? ownedCondition=ExpCS ')' '{' ownedExps+=ExpressionStatementCS*
	//	'}';
	public WhileExpCSElements getWhileExpCSAccess() {
		return pWhileExpCS;
	}

	public ParserRule getWhileExpCSRule() {
		return getWhileExpCSAccess().getRule();
	}

	////generate essentialOCLCST "http://www.eclipse.org/ocl/3.0.0/EssentialOCLCST"
	// Model ContextCS:
	//	ownedExpression=ExpCS;
	public EssentialOCLGrammarAccess.ModelElements getModelAccess() {
		return gaEssentialOCL.getModelAccess();
	}

	public ParserRule getModelRule() {
		return getModelAccess().getRule();
	}

	///** <<<This is a join point for derived grammars - replace with a more disciplined grammar extensibility>>> */
	//EssentialOCLReservedKeyword:
	//	'and' | 'else' | 'endif' | 'if' | 'implies' | 'in' | 'let' | 'not' | 'or' | 'then' | 'xor';
	public EssentialOCLGrammarAccess.EssentialOCLReservedKeywordElements getEssentialOCLReservedKeywordAccess() {
		return gaEssentialOCL.getEssentialOCLReservedKeywordAccess();
	}

	public ParserRule getEssentialOCLReservedKeywordRule() {
		return getEssentialOCLReservedKeywordAccess().getRule();
	}

	///** <<<This is a join point for derived grammars - replace with a more disciplined grammar extensibility>>> */
	//EssentialOCLUnaryOperatorName:
	//	'-' | 'not';
	public EssentialOCLGrammarAccess.EssentialOCLUnaryOperatorNameElements getEssentialOCLUnaryOperatorNameAccess() {
		return gaEssentialOCL.getEssentialOCLUnaryOperatorNameAccess();
	}

	public ParserRule getEssentialOCLUnaryOperatorNameRule() {
		return getEssentialOCLUnaryOperatorNameAccess().getRule();
	}

	///** <<<This is a join point for derived grammars - replace with a more disciplined grammar extensibility>>> */
	//EssentialOCLInfixOperatorName:
	//	'*' | '/' | '+' | '-' | '>' | '<' | '>=' | '<=' | '=' | '<>' | 'and' | 'or' | 'xor' | 'implies';
	public EssentialOCLGrammarAccess.EssentialOCLInfixOperatorNameElements getEssentialOCLInfixOperatorNameAccess() {
		return gaEssentialOCL.getEssentialOCLInfixOperatorNameAccess();
	}

	public ParserRule getEssentialOCLInfixOperatorNameRule() {
		return getEssentialOCLInfixOperatorNameAccess().getRule();
	}

	///** <<<This is a join point for derived grammars - replace with a more disciplined grammar extensibility>>> */
	//EssentialOCLNavigationOperatorName:
	//	'.' | '->' | '?.' | '?->';
	public EssentialOCLGrammarAccess.EssentialOCLNavigationOperatorNameElements getEssentialOCLNavigationOperatorNameAccess() {
		return gaEssentialOCL.getEssentialOCLNavigationOperatorNameAccess();
	}

	public ParserRule getEssentialOCLNavigationOperatorNameRule() {
		return getEssentialOCLNavigationOperatorNameAccess().getRule();
	}

	//BinaryOperatorName:
	//	InfixOperatorName | NavigationOperatorName;
	public EssentialOCLGrammarAccess.BinaryOperatorNameElements getBinaryOperatorNameAccess() {
		return gaEssentialOCL.getBinaryOperatorNameAccess();
	}

	public ParserRule getBinaryOperatorNameRule() {
		return getBinaryOperatorNameAccess().getRule();
	}

	//InfixOperatorName:
	//	EssentialOCLInfixOperatorName;
	public EssentialOCLGrammarAccess.InfixOperatorNameElements getInfixOperatorNameAccess() {
		return gaEssentialOCL.getInfixOperatorNameAccess();
	}

	public ParserRule getInfixOperatorNameRule() {
		return getInfixOperatorNameAccess().getRule();
	}

	//NavigationOperatorName:
	//	EssentialOCLNavigationOperatorName;
	public EssentialOCLGrammarAccess.NavigationOperatorNameElements getNavigationOperatorNameAccess() {
		return gaEssentialOCL.getNavigationOperatorNameAccess();
	}

	public ParserRule getNavigationOperatorNameRule() {
		return getNavigationOperatorNameAccess().getRule();
	}

	//UnaryOperatorName:
	//	EssentialOCLUnaryOperatorName;
	public EssentialOCLGrammarAccess.UnaryOperatorNameElements getUnaryOperatorNameAccess() {
		return gaEssentialOCL.getUnaryOperatorNameAccess();
	}

	public ParserRule getUnaryOperatorNameRule() {
		return getUnaryOperatorNameAccess().getRule();
	}

	////---------------------------------------------------------------------
	// //  Names
	//
	////---------------------------------------------------------------------
	//
	///** <<<This is a join point for derived grammars - replace with a more disciplined grammar extensibility>>> */
	//EssentialOCLUnrestrictedName:
	//	Identifier;
	public EssentialOCLGrammarAccess.EssentialOCLUnrestrictedNameElements getEssentialOCLUnrestrictedNameAccess() {
		return gaEssentialOCL.getEssentialOCLUnrestrictedNameAccess();
	}

	public ParserRule getEssentialOCLUnrestrictedNameRule() {
		return getEssentialOCLUnrestrictedNameAccess().getRule();
	}

	//UnrestrictedName:
	//	EssentialOCLUnrestrictedName;
	public EssentialOCLGrammarAccess.UnrestrictedNameElements getUnrestrictedNameAccess() {
		return gaEssentialOCL.getUnrestrictedNameAccess();
	}

	public ParserRule getUnrestrictedNameRule() {
		return getUnrestrictedNameAccess().getRule();
	}

	///** <<<This is a join point for derived grammars - replace with a more disciplined grammar extensibility>>> */
	//EssentialOCLUnreservedName:
	//	UnrestrictedName | CollectionTypeIdentifier | PrimitiveTypeIdentifier | 'Map' | 'Tuple';
	public EssentialOCLGrammarAccess.EssentialOCLUnreservedNameElements getEssentialOCLUnreservedNameAccess() {
		return gaEssentialOCL.getEssentialOCLUnreservedNameAccess();
	}

	public ParserRule getEssentialOCLUnreservedNameRule() {
		return getEssentialOCLUnreservedNameAccess().getRule();
	}

	//UnreservedName:
	//	EssentialOCLUnreservedName;
	public EssentialOCLGrammarAccess.UnreservedNameElements getUnreservedNameAccess() {
		return gaEssentialOCL.getUnreservedNameAccess();
	}

	public ParserRule getUnreservedNameRule() {
		return getUnreservedNameAccess().getRule();
	}

	//URIPathNameCS base::PathNameCS:
	//	ownedPathElements+=URIFirstPathElementCS ('::' ownedPathElements+=NextPathElementCS)*;
	public EssentialOCLGrammarAccess.URIPathNameCSElements getURIPathNameCSAccess() {
		return gaEssentialOCL.getURIPathNameCSAccess();
	}

	public ParserRule getURIPathNameCSRule() {
		return getURIPathNameCSAccess().getRule();
	}

	//URIFirstPathElementCS base::PathElementCS:
	//	referredElement=[pivot::NamedElement|UnrestrictedName] | {base::PathElementWithURICS}
	//	referredElement=[pivot::Namespace|URI];
	public EssentialOCLGrammarAccess.URIFirstPathElementCSElements getURIFirstPathElementCSAccess() {
		return gaEssentialOCL.getURIFirstPathElementCSAccess();
	}

	public ParserRule getURIFirstPathElementCSRule() {
		return getURIFirstPathElementCSAccess().getRule();
	}

	////---------------------------------------------------------------------
	// //  Types
	//
	////---------------------------------------------------------------------
	// PrimitiveTypeIdentifier:
	//	'Boolean' | 'Integer' | 'Real' | 'String' | 'UnlimitedNatural' | 'OclAny' | 'OclInvalid' | 'OclVoid';
	public EssentialOCLGrammarAccess.PrimitiveTypeIdentifierElements getPrimitiveTypeIdentifierAccess() {
		return gaEssentialOCL.getPrimitiveTypeIdentifierAccess();
	}

	public ParserRule getPrimitiveTypeIdentifierRule() {
		return getPrimitiveTypeIdentifierAccess().getRule();
	}

	//PrimitiveTypeCS base::PrimitiveTypeRefCS:
	//	name=PrimitiveTypeIdentifier;
	public EssentialOCLGrammarAccess.PrimitiveTypeCSElements getPrimitiveTypeCSAccess() {
		return gaEssentialOCL.getPrimitiveTypeCSAccess();
	}

	public ParserRule getPrimitiveTypeCSRule() {
		return getPrimitiveTypeCSAccess().getRule();
	}

	//CollectionTypeIdentifier:
	//	'Set' | 'Bag' | 'Sequence' | 'Collection' | 'OrderedSet';
	public EssentialOCLGrammarAccess.CollectionTypeIdentifierElements getCollectionTypeIdentifierAccess() {
		return gaEssentialOCL.getCollectionTypeIdentifierAccess();
	}

	public ParserRule getCollectionTypeIdentifierRule() {
		return getCollectionTypeIdentifierAccess().getRule();
	}

	//CollectionTypeCS:
	//	name=CollectionTypeIdentifier ('(' ownedType=TypeExpWithoutMultiplicityCS ownedCollectionMultiplicity=MultiplicityCS?
	//	')')?;
	public EssentialOCLGrammarAccess.CollectionTypeCSElements getCollectionTypeCSAccess() {
		return gaEssentialOCL.getCollectionTypeCSAccess();
	}

	public ParserRule getCollectionTypeCSRule() {
		return getCollectionTypeCSAccess().getRule();
	}

	//MapTypeCS:
	//	name='Map' ('(' ownedKeyType=TypeExpCS ',' ownedValueType=TypeExpCS ')')?;
	public EssentialOCLGrammarAccess.MapTypeCSElements getMapTypeCSAccess() {
		return gaEssentialOCL.getMapTypeCSAccess();
	}

	public ParserRule getMapTypeCSRule() {
		return getMapTypeCSAccess().getRule();
	}

	//TupleTypeCS base::TupleTypeCS:
	//	name='Tuple' ('(' (ownedParts+=TuplePartCS (',' ownedParts+=TuplePartCS)*)? ')')?;
	public EssentialOCLGrammarAccess.TupleTypeCSElements getTupleTypeCSAccess() {
		return gaEssentialOCL.getTupleTypeCSAccess();
	}

	public ParserRule getTupleTypeCSRule() {
		return getTupleTypeCSAccess().getRule();
	}

	//TuplePartCS base::TuplePartCS:
	//	name=UnrestrictedName ':' ownedType=TypeExpCS;
	public EssentialOCLGrammarAccess.TuplePartCSElements getTuplePartCSAccess() {
		return gaEssentialOCL.getTuplePartCSAccess();
	}

	public ParserRule getTuplePartCSRule() {
		return getTuplePartCSAccess().getRule();
	}

	////---------------------------------------------------------------------
	// //  Literals
	//
	////---------------------------------------------------------------------
	// CollectionLiteralExpCS:
	//	ownedType=CollectionTypeCS '{' (ownedParts+=CollectionLiteralPartCS (',' ownedParts+=CollectionLiteralPartCS)*)? '}';
	public EssentialOCLGrammarAccess.CollectionLiteralExpCSElements getCollectionLiteralExpCSAccess() {
		return gaEssentialOCL.getCollectionLiteralExpCSAccess();
	}

	public ParserRule getCollectionLiteralExpCSRule() {
		return getCollectionLiteralExpCSAccess().getRule();
	}

	//CollectionLiteralPartCS:
	//	ownedExpression=ExpCS ('..' ownedLastExpression=ExpCS)? | ownedExpression=PatternExpCS;
	public EssentialOCLGrammarAccess.CollectionLiteralPartCSElements getCollectionLiteralPartCSAccess() {
		return gaEssentialOCL.getCollectionLiteralPartCSAccess();
	}

	public ParserRule getCollectionLiteralPartCSRule() {
		return getCollectionLiteralPartCSAccess().getRule();
	}

	//CollectionPatternCS:
	//	ownedType=CollectionTypeCS '{' (ownedParts+=PatternExpCS (',' ownedParts+=PatternExpCS)* ('++'
	//	restVariableName=Identifier))? '}';
	public EssentialOCLGrammarAccess.CollectionPatternCSElements getCollectionPatternCSAccess() {
		return gaEssentialOCL.getCollectionPatternCSAccess();
	}

	public ParserRule getCollectionPatternCSRule() {
		return getCollectionPatternCSAccess().getRule();
	}

	//ShadowPartCS:
	//	referredProperty=[pivot::Property|UnrestrictedName] '=' ownedInitExpression=(ExpCS | PatternExpCS) |
	//	ownedInitExpression=StringLiteralExpCS;
	public EssentialOCLGrammarAccess.ShadowPartCSElements getShadowPartCSAccess() {
		return gaEssentialOCL.getShadowPartCSAccess();
	}

	public ParserRule getShadowPartCSRule() {
		return getShadowPartCSAccess().getRule();
	}

	//PatternExpCS:
	//	patternVariableName=UnrestrictedName? ':' ownedPatternType=TypeExpCS;
	public EssentialOCLGrammarAccess.PatternExpCSElements getPatternExpCSAccess() {
		return gaEssentialOCL.getPatternExpCSAccess();
	}

	public ParserRule getPatternExpCSRule() {
		return getPatternExpCSAccess().getRule();
	}

	//LambdaLiteralExpCS:
	//	'Lambda' '{' ownedExpressionCS=ExpCS '}';
	public EssentialOCLGrammarAccess.LambdaLiteralExpCSElements getLambdaLiteralExpCSAccess() {
		return gaEssentialOCL.getLambdaLiteralExpCSAccess();
	}

	public ParserRule getLambdaLiteralExpCSRule() {
		return getLambdaLiteralExpCSAccess().getRule();
	}

	//MapLiteralExpCS:
	//	ownedType=MapTypeCS '{' (ownedParts+=MapLiteralPartCS (',' ownedParts+=MapLiteralPartCS)*)? '}';
	public EssentialOCLGrammarAccess.MapLiteralExpCSElements getMapLiteralExpCSAccess() {
		return gaEssentialOCL.getMapLiteralExpCSAccess();
	}

	public ParserRule getMapLiteralExpCSRule() {
		return getMapLiteralExpCSAccess().getRule();
	}

	//MapLiteralPartCS:
	//	ownedKey=ExpCS '<-' ownedValue=ExpCS;
	public EssentialOCLGrammarAccess.MapLiteralPartCSElements getMapLiteralPartCSAccess() {
		return gaEssentialOCL.getMapLiteralPartCSAccess();
	}

	public ParserRule getMapLiteralPartCSRule() {
		return getMapLiteralPartCSAccess().getRule();
	}

	//PrimitiveLiteralExpCS:
	//	NumberLiteralExpCS | StringLiteralExpCS | BooleanLiteralExpCS | UnlimitedNaturalLiteralExpCS | InvalidLiteralExpCS |
	//	NullLiteralExpCS;
	public EssentialOCLGrammarAccess.PrimitiveLiteralExpCSElements getPrimitiveLiteralExpCSAccess() {
		return gaEssentialOCL.getPrimitiveLiteralExpCSAccess();
	}

	public ParserRule getPrimitiveLiteralExpCSRule() {
		return getPrimitiveLiteralExpCSAccess().getRule();
	}

	//TupleLiteralExpCS:
	//	'Tuple' '{' ownedParts+=TupleLiteralPartCS (',' ownedParts+=TupleLiteralPartCS)* '}';
	public EssentialOCLGrammarAccess.TupleLiteralExpCSElements getTupleLiteralExpCSAccess() {
		return gaEssentialOCL.getTupleLiteralExpCSAccess();
	}

	public ParserRule getTupleLiteralExpCSRule() {
		return getTupleLiteralExpCSAccess().getRule();
	}

	//TupleLiteralPartCS:
	//	name=UnrestrictedName (':' ownedType=TypeExpCS)? '=' ownedInitExpression=ExpCS;
	public EssentialOCLGrammarAccess.TupleLiteralPartCSElements getTupleLiteralPartCSAccess() {
		return gaEssentialOCL.getTupleLiteralPartCSAccess();
	}

	public ParserRule getTupleLiteralPartCSRule() {
		return getTupleLiteralPartCSAccess().getRule();
	}

	//NumberLiteralExpCS:
	//	symbol=NUMBER_LITERAL;
	public EssentialOCLGrammarAccess.NumberLiteralExpCSElements getNumberLiteralExpCSAccess() {
		return gaEssentialOCL.getNumberLiteralExpCSAccess();
	}

	public ParserRule getNumberLiteralExpCSRule() {
		return getNumberLiteralExpCSAccess().getRule();
	}

	//StringLiteralExpCS:
	//	segments+=super::StringLiteral+;
	public EssentialOCLGrammarAccess.StringLiteralExpCSElements getStringLiteralExpCSAccess() {
		return gaEssentialOCL.getStringLiteralExpCSAccess();
	}

	public ParserRule getStringLiteralExpCSRule() {
		return getStringLiteralExpCSAccess().getRule();
	}

	//BooleanLiteralExpCS:
	//	symbol='true' | symbol='false';
	public EssentialOCLGrammarAccess.BooleanLiteralExpCSElements getBooleanLiteralExpCSAccess() {
		return gaEssentialOCL.getBooleanLiteralExpCSAccess();
	}

	public ParserRule getBooleanLiteralExpCSRule() {
		return getBooleanLiteralExpCSAccess().getRule();
	}

	//UnlimitedNaturalLiteralExpCS:
	//	{UnlimitedNaturalLiteralExpCS} '*';
	public EssentialOCLGrammarAccess.UnlimitedNaturalLiteralExpCSElements getUnlimitedNaturalLiteralExpCSAccess() {
		return gaEssentialOCL.getUnlimitedNaturalLiteralExpCSAccess();
	}

	public ParserRule getUnlimitedNaturalLiteralExpCSRule() {
		return getUnlimitedNaturalLiteralExpCSAccess().getRule();
	}

	//InvalidLiteralExpCS:
	//	{InvalidLiteralExpCS} 'invalid';
	public EssentialOCLGrammarAccess.InvalidLiteralExpCSElements getInvalidLiteralExpCSAccess() {
		return gaEssentialOCL.getInvalidLiteralExpCSAccess();
	}

	public ParserRule getInvalidLiteralExpCSRule() {
		return getInvalidLiteralExpCSAccess().getRule();
	}

	//NullLiteralExpCS:
	//	{NullLiteralExpCS} 'null';
	public EssentialOCLGrammarAccess.NullLiteralExpCSElements getNullLiteralExpCSAccess() {
		return gaEssentialOCL.getNullLiteralExpCSAccess();
	}

	public ParserRule getNullLiteralExpCSRule() {
		return getNullLiteralExpCSAccess().getRule();
	}

	//TypeLiteralWithMultiplicityCS base::TypedRefCS:
	//	super::TypeLiteralCS ownedMultiplicity=MultiplicityCS?;
	public EssentialOCLGrammarAccess.TypeLiteralWithMultiplicityCSElements getTypeLiteralWithMultiplicityCSAccess() {
		return gaEssentialOCL.getTypeLiteralWithMultiplicityCSAccess();
	}

	public ParserRule getTypeLiteralWithMultiplicityCSRule() {
		return getTypeLiteralWithMultiplicityCSAccess().getRule();
	}

	//TypeLiteralExpCS:
	//	ownedType=TypeLiteralWithMultiplicityCS;
	public EssentialOCLGrammarAccess.TypeLiteralExpCSElements getTypeLiteralExpCSAccess() {
		return gaEssentialOCL.getTypeLiteralExpCSAccess();
	}

	public ParserRule getTypeLiteralExpCSRule() {
		return getTypeLiteralExpCSAccess().getRule();
	}

	//TypeNameExpCS:
	//	ownedPathName=PathNameCS (ownedCurlyBracketedClause=CurlyBracketedClauseCS ('{' ownedPatternGuard=ExpCS '}')?)?;
	public EssentialOCLGrammarAccess.TypeNameExpCSElements getTypeNameExpCSAccess() {
		return gaEssentialOCL.getTypeNameExpCSAccess();
	}

	public ParserRule getTypeNameExpCSRule() {
		return getTypeNameExpCSAccess().getRule();
	}

	//TypeExpWithoutMultiplicityCS base::TypedRefCS:
	//	TypeNameExpCS | super::TypeLiteralCS | CollectionPatternCS;
	public EssentialOCLGrammarAccess.TypeExpWithoutMultiplicityCSElements getTypeExpWithoutMultiplicityCSAccess() {
		return gaEssentialOCL.getTypeExpWithoutMultiplicityCSAccess();
	}

	public ParserRule getTypeExpWithoutMultiplicityCSRule() {
		return getTypeExpWithoutMultiplicityCSAccess().getRule();
	}

	//TypeExpCS base::TypedRefCS:
	//	TypeExpWithoutMultiplicityCS ownedMultiplicity=MultiplicityCS?;
	public EssentialOCLGrammarAccess.TypeExpCSElements getTypeExpCSAccess() {
		return gaEssentialOCL.getTypeExpCSAccess();
	}

	public ParserRule getTypeExpCSRule() {
		return getTypeExpCSAccess().getRule();
	}

	////---------------------------------------------------------------------
	// //  Expressions
	//
	////---------------------------------------------------------------------
	//
	//// An ExpCS permits a LetExpCS only in the final term to ensure
	//
	////  that let is right associative, whereas infix operators are left associative.
	//
	////   a = 64 / 16 / let b : Integer in 8 / let c : Integer in 4
	// // is
	//
	////   a = (64 / 16) / (let b : Integer in 8 / (let c : Integer in 4 ))
	//
	///* An expression elaborates a prefixed expression with zero or more binary operator and expression suffixes.
	// * An optionally prefixed let expression is permitted except when suffixed with further expressions.*/
	//ExpCS:
	//	PrefixedPrimaryExpCS ({InfixExpCS.ownedLeft=current} name=BinaryOperatorName ownedRight=ExpCS)? | PrefixedLetExpCS;
	public EssentialOCLGrammarAccess.ExpCSElements getExpCSAccess() {
		return gaEssentialOCL.getExpCSAccess();
	}

	public ParserRule getExpCSRule() {
		return getExpCSAccess().getRule();
	}

	///* A prefixed let expression elaborates a let expression with zero or more unary prefix operators. */ PrefixedLetExpCS
	//ExpCS:
	//	{PrefixExpCS} name=UnaryOperatorName ownedRight=PrefixedLetExpCS | LetExpCS;
	public EssentialOCLGrammarAccess.PrefixedLetExpCSElements getPrefixedLetExpCSAccess() {
		return gaEssentialOCL.getPrefixedLetExpCSAccess();
	}

	public ParserRule getPrefixedLetExpCSRule() {
		return getPrefixedLetExpCSAccess().getRule();
	}

	///* A prefixed primary expression elaborates a primary expression with zero or more unary prefix operators. */
	//PrefixedPrimaryExpCS ExpCS:
	//	{PrefixExpCS} name=UnaryOperatorName ownedRight=PrefixedPrimaryExpCS | super::PrimaryExpCS;
	public EssentialOCLGrammarAccess.PrefixedPrimaryExpCSElements getPrefixedPrimaryExpCSAccess() {
		return gaEssentialOCL.getPrefixedPrimaryExpCSAccess();
	}

	public ParserRule getPrefixedPrimaryExpCSRule() {
		return getPrefixedPrimaryExpCSAccess().getRule();
	}

	///* A name expression is a generalised rule for expressions that start with a name and which may be followed by square, round or
	// * curly bracket clauses and optionally an @pre as well.*/
	//NameExpCS:
	//	ownedPathName=PathNameCS ownedSquareBracketedClauses+=SquareBracketedClauseCS*
	//	ownedRoundBracketedClause=RoundBracketedClauseCS? ownedCurlyBracketedClause=CurlyBracketedClauseCS? (isPre?='@'
	//	'pre')?;
	public EssentialOCLGrammarAccess.NameExpCSElements getNameExpCSAccess() {
		return gaEssentialOCL.getNameExpCSAccess();
	}

	public ParserRule getNameExpCSRule() {
		return getNameExpCSAccess().getRule();
	}

	///* A curly bracket clause is a generalized rule for the literal arguments of collections, maps, tuples and shadows.*/
	//CurlyBracketedClauseCS:
	//	{CurlyBracketedClauseCS} '{' (ownedParts+=ShadowPartCS (',' ownedParts+=ShadowPartCS)*)? '}';
	public EssentialOCLGrammarAccess.CurlyBracketedClauseCSElements getCurlyBracketedClauseCSAccess() {
		return gaEssentialOCL.getCurlyBracketedClauseCSAccess();
	}

	public ParserRule getCurlyBracketedClauseCSRule() {
		return getCurlyBracketedClauseCSAccess().getRule();
	}

	///* A curly bracket clause is a generalized rule for template specialisations and operations arguments.*/
	//RoundBracketedClauseCS:
	//	{RoundBracketedClauseCS} '(' (ownedArguments+=NavigatingArgCS ownedArguments+=NavigatingCommaArgCS*
	//	(ownedArguments+=NavigatingSemiArgCS ownedArguments+=NavigatingCommaArgCS*)? (ownedArguments+=NavigatingBarArgCS
	//	ownedArguments+=NavigatingCommaArgCS*)*)? ')';
	public EssentialOCLGrammarAccess.RoundBracketedClauseCSElements getRoundBracketedClauseCSAccess() {
		return gaEssentialOCL.getRoundBracketedClauseCSAccess();
	}

	public ParserRule getRoundBracketedClauseCSRule() {
		return getRoundBracketedClauseCSAccess().getRule();
	}

	///* A square bracket clause is a generalized rule for association class qualifiers and roles.*/ SquareBracketedClauseCS:
	//	'[' ownedTerms+=ExpCS (',' ownedTerms+=ExpCS)* ']';
	public EssentialOCLGrammarAccess.SquareBracketedClauseCSElements getSquareBracketedClauseCSAccess() {
		return gaEssentialOCL.getSquareBracketedClauseCSAccess();
	}

	public ParserRule getSquareBracketedClauseCSRule() {
		return getSquareBracketedClauseCSAccess().getRule();
	}

	///* A navigating argument is a generalized rule for the first argument in a round bracket clause. This is typically the first operation
	// * parameter or an iterator. */
	//NavigatingArgCS:
	//	ownedNameExpression=NavigatingArgExpCS (':' ownedType=TypeExpCS ('=' ownedInitExpression=ExpCS)? | 'in'
	//	ownedInitExpression=ExpCS)? | ':' ownedType=TypeExpCS;
	public EssentialOCLGrammarAccess.NavigatingArgCSElements getNavigatingArgCSAccess() {
		return gaEssentialOCL.getNavigatingArgCSAccess();
	}

	public ParserRule getNavigatingArgCSRule() {
		return getNavigatingArgCSAccess().getRule();
	}

	//// Type-less init is an illegal infix expression
	//
	///* A navigating bar argument is a generalized rule for a bar-prefixed argument in a round bracket clause. This is typically the body of an iteration. */
	//NavigatingBarArgCS NavigatingArgCS:
	//	prefix='|' ownedNameExpression=NavigatingArgExpCS (':' ownedType=TypeExpCS ('=' ownedInitExpression=ExpCS)?)?;
	public EssentialOCLGrammarAccess.NavigatingBarArgCSElements getNavigatingBarArgCSAccess() {
		return gaEssentialOCL.getNavigatingBarArgCSAccess();
	}

	public ParserRule getNavigatingBarArgCSRule() {
		return getNavigatingBarArgCSAccess().getRule();
	}

	//// Type-less init is an illegal infix expression
	//
	///* A navigating comma argument is a generalized rule for non-first argument in a round bracket clause. These are typically non-first operation
	// * parameters or a second iterator. */
	//NavigatingCommaArgCS NavigatingArgCS:
	//	prefix=',' ownedNameExpression=NavigatingArgExpCS (':' ownedType=TypeExpCS ('=' ownedInitExpression=ExpCS)? | 'in'
	//	ownedInitExpression=ExpCS)?;
	public EssentialOCLGrammarAccess.NavigatingCommaArgCSElements getNavigatingCommaArgCSAccess() {
		return gaEssentialOCL.getNavigatingCommaArgCSAccess();
	}

	public ParserRule getNavigatingCommaArgCSRule() {
		return getNavigatingCommaArgCSAccess().getRule();
	}

	//// Type-less init is an illegal infix expression
	//
	///* A navigating semi argument is a generalized rule for a semicolon prefixed argument in a round bracket clause. This is typically an iterate accumulator. */
	//NavigatingSemiArgCS NavigatingArgCS:
	//	prefix=';' ownedNameExpression=NavigatingArgExpCS (':' ownedType=TypeExpCS ('=' ownedInitExpression=ExpCS)?)?;
	public EssentialOCLGrammarAccess.NavigatingSemiArgCSElements getNavigatingSemiArgCSAccess() {
		return gaEssentialOCL.getNavigatingSemiArgCSAccess();
	}

	public ParserRule getNavigatingSemiArgCSRule() {
		return getNavigatingSemiArgCSAccess().getRule();
	}

	//// Type-less init is an illegal infix expression
	// NavigatingArgExpCS ExpCS:
	//	ExpCS //	'?'	-- defined by Complete OCL
	//;
	public EssentialOCLGrammarAccess.NavigatingArgExpCSElements getNavigatingArgExpCSAccess() {
		return gaEssentialOCL.getNavigatingArgExpCSAccess();
	}

	public ParserRule getNavigatingArgExpCSRule() {
		return getNavigatingArgExpCSAccess().getRule();
	}

	//IfExpCS:
	//	'if' ownedCondition=(ExpCS | PatternExpCS) 'then' ownedThenExpression=ExpCS //	ifThenExpressions+=IfThenExpCS
	//
	//	ownedIfThenExpressions+=ElseIfThenExpCS* 'else' ownedElseExpression=ExpCS 'endif';
	public EssentialOCLGrammarAccess.IfExpCSElements getIfExpCSAccess() {
		return gaEssentialOCL.getIfExpCSAccess();
	}

	public ParserRule getIfExpCSRule() {
		return getIfExpCSAccess().getRule();
	}

	////IfThenExpCS returns IfThenExpCS:
	// //	'if' condition=ExpCS
	// //	'then' thenExpression=ExpCS
	// //;
	// ElseIfThenExpCS
	//IfThenExpCS:
	//	'elseif' ownedCondition=ExpCS 'then' ownedThenExpression=ExpCS;
	public EssentialOCLGrammarAccess.ElseIfThenExpCSElements getElseIfThenExpCSAccess() {
		return gaEssentialOCL.getElseIfThenExpCSAccess();
	}

	public ParserRule getElseIfThenExpCSRule() {
		return getElseIfThenExpCSAccess().getRule();
	}

	//LetExpCS:
	//	'let' ownedVariables+=LetVariableCS (',' ownedVariables+=LetVariableCS)* 'in' ownedInExpression=ExpCS;
	public EssentialOCLGrammarAccess.LetExpCSElements getLetExpCSAccess() {
		return gaEssentialOCL.getLetExpCSAccess();
	}

	public ParserRule getLetExpCSRule() {
		return getLetExpCSAccess().getRule();
	}

	//LetVariableCS:
	//	name=UnrestrictedName ownedRoundBracketedClause=RoundBracketedClauseCS? (':' ownedType=TypeExpCS)? '='
	//	ownedInitExpression=ExpCS;
	public EssentialOCLGrammarAccess.LetVariableCSElements getLetVariableCSAccess() {
		return gaEssentialOCL.getLetVariableCSAccess();
	}

	public ParserRule getLetVariableCSRule() {
		return getLetVariableCSAccess().getRule();
	}

	//NestedExpCS:
	//	'(' ownedExpression=ExpCS ')';
	public EssentialOCLGrammarAccess.NestedExpCSElements getNestedExpCSAccess() {
		return gaEssentialOCL.getNestedExpCSAccess();
	}

	public ParserRule getNestedExpCSRule() {
		return getNestedExpCSAccess().getRule();
	}

	//SelfExpCS:
	//	{SelfExpCS} 'self';
	public EssentialOCLGrammarAccess.SelfExpCSElements getSelfExpCSAccess() {
		return gaEssentialOCL.getSelfExpCSAccess();
	}

	public ParserRule getSelfExpCSRule() {
		return getSelfExpCSAccess().getRule();
	}

	//MultiplicityBoundsCS:
	//	lowerBound=LOWER ('..' upperBound=UPPER)?;
	public BaseGrammarAccess.MultiplicityBoundsCSElements getMultiplicityBoundsCSAccess() {
		return gaBase.getMultiplicityBoundsCSAccess();
	}

	public ParserRule getMultiplicityBoundsCSRule() {
		return getMultiplicityBoundsCSAccess().getRule();
	}

	//MultiplicityCS:
	//	'[' (MultiplicityBoundsCS | MultiplicityStringCS) ('|?' | isNullFree?='|1')? ']';
	public BaseGrammarAccess.MultiplicityCSElements getMultiplicityCSAccess() {
		return gaBase.getMultiplicityCSAccess();
	}

	public ParserRule getMultiplicityCSRule() {
		return getMultiplicityCSAccess().getRule();
	}

	//MultiplicityStringCS:
	//	stringBounds=('*' | '+' | '?');
	public BaseGrammarAccess.MultiplicityStringCSElements getMultiplicityStringCSAccess() {
		return gaBase.getMultiplicityStringCSAccess();
	}

	public ParserRule getMultiplicityStringCSRule() {
		return getMultiplicityStringCSAccess().getRule();
	}

	//PathNameCS:
	//	ownedPathElements+=FirstPathElementCS ('::' ownedPathElements+=NextPathElementCS)*;
	public BaseGrammarAccess.PathNameCSElements getPathNameCSAccess() {
		return gaBase.getPathNameCSAccess();
	}

	public ParserRule getPathNameCSRule() {
		return getPathNameCSAccess().getRule();
	}

	//FirstPathElementCS PathElementCS:
	//	referredElement=[pivot::NamedElement|super::UnrestrictedName];
	public BaseGrammarAccess.FirstPathElementCSElements getFirstPathElementCSAccess() {
		return gaBase.getFirstPathElementCSAccess();
	}

	public ParserRule getFirstPathElementCSRule() {
		return getFirstPathElementCSAccess().getRule();
	}

	//NextPathElementCS PathElementCS:
	//	referredElement=[pivot::NamedElement|super::UnreservedName];
	public BaseGrammarAccess.NextPathElementCSElements getNextPathElementCSAccess() {
		return gaBase.getNextPathElementCSAccess();
	}

	public ParserRule getNextPathElementCSRule() {
		return getNextPathElementCSAccess().getRule();
	}

	//TemplateBindingCS:
	//	ownedSubstitutions+=TemplateParameterSubstitutionCS (',' ownedSubstitutions+=TemplateParameterSubstitutionCS)*
	//	ownedMultiplicity=MultiplicityCS?;
	public BaseGrammarAccess.TemplateBindingCSElements getTemplateBindingCSAccess() {
		return gaBase.getTemplateBindingCSAccess();
	}

	public ParserRule getTemplateBindingCSRule() {
		return getTemplateBindingCSAccess().getRule();
	}

	//TemplateParameterSubstitutionCS:
	//	ownedActualParameter=TypeRefCS;
	public BaseGrammarAccess.TemplateParameterSubstitutionCSElements getTemplateParameterSubstitutionCSAccess() {
		return gaBase.getTemplateParameterSubstitutionCSAccess();
	}

	public ParserRule getTemplateParameterSubstitutionCSRule() {
		return getTemplateParameterSubstitutionCSAccess().getRule();
	}

	//TemplateSignatureCS:
	//	'(' ownedParameters+=TypeParameterCS (',' ownedParameters+=TypeParameterCS)* ')';
	public BaseGrammarAccess.TemplateSignatureCSElements getTemplateSignatureCSAccess() {
		return gaBase.getTemplateSignatureCSAccess();
	}

	public ParserRule getTemplateSignatureCSRule() {
		return getTemplateSignatureCSAccess().getRule();
	}

	//TypeParameterCS:
	//	name=super::UnrestrictedName ('extends' ownedExtends+=TypedRefCS ('&&' ownedExtends+=TypedRefCS)*)?;
	public BaseGrammarAccess.TypeParameterCSElements getTypeParameterCSAccess() {
		return gaBase.getTypeParameterCSAccess();
	}

	public ParserRule getTypeParameterCSRule() {
		return getTypeParameterCSAccess().getRule();
	}

	//TypeRefCS:
	//	TypedRefCS | WildcardTypeRefCS;
	public BaseGrammarAccess.TypeRefCSElements getTypeRefCSAccess() {
		return gaBase.getTypeRefCSAccess();
	}

	public ParserRule getTypeRefCSRule() {
		return getTypeRefCSAccess().getRule();
	}

	//TypedRefCS:
	//	TypedTypeRefCS;
	public BaseGrammarAccess.TypedRefCSElements getTypedRefCSAccess() {
		return gaBase.getTypedRefCSAccess();
	}

	public ParserRule getTypedRefCSRule() {
		return getTypedRefCSAccess().getRule();
	}

	//TypedTypeRefCS:
	//	ownedPathName=PathNameCS ('(' ownedBinding=TemplateBindingCS ')')?;
	public BaseGrammarAccess.TypedTypeRefCSElements getTypedTypeRefCSAccess() {
		return gaBase.getTypedTypeRefCSAccess();
	}

	public ParserRule getTypedTypeRefCSRule() {
		return getTypedTypeRefCSAccess().getRule();
	}

	//WildcardTypeRefCS:
	//	{WildcardTypeRefCS} '?' ('extends' ownedExtends=TypedRefCS)?;
	public BaseGrammarAccess.WildcardTypeRefCSElements getWildcardTypeRefCSAccess() {
		return gaBase.getWildcardTypeRefCSAccess();
	}

	public ParserRule getWildcardTypeRefCSRule() {
		return getWildcardTypeRefCSAccess().getRule();
	}

	//ID:
	//	SIMPLE_ID | ESCAPED_ID;
	public BaseGrammarAccess.IDElements getIDAccess() {
		return gaBase.getIDAccess();
	}

	public ParserRule getIDRule() {
		return getIDAccess().getRule();
	}

	//Identifier:
	//	ID;
	public BaseGrammarAccess.IdentifierElements getIdentifierAccess() {
		return gaBase.getIdentifierAccess();
	}

	public ParserRule getIdentifierRule() {
		return getIdentifierAccess().getRule();
	}

	///* A lowerbounded integer is used to define the lowerbound of a collection multiplicity. The value may not be the unlimited value. */
	//LOWER ecore::EInt:
	//	INT;
	public BaseGrammarAccess.LOWERElements getLOWERAccess() {
		return gaBase.getLOWERAccess();
	}

	public ParserRule getLOWERRule() {
		return getLOWERAccess().getRule();
	}

	///* A number may be an integer or floating point value. The declaration here appears to be that for just an integer. This is to avoid
	// * lookahead conflicts in simple lexers between a dot within a floating point number and the dot-dot in a CollectionLiteralPartCS. A
	// * practical implementation should give high priority to a successful parse of INT ('.' INT)? (('e' | 'E') ('+' | '-')? INT)? than
	// * to the unsuccessful partial parse of INT '..'. The type of the INT terminal is String to allow the floating point syntax to be used.
	// */
	//NUMBER_LITERAL BigNumber:
	//	INT;
	public BaseGrammarAccess.NUMBER_LITERALElements getNUMBER_LITERALAccess() {
		return gaBase.getNUMBER_LITERALAccess();
	}

	public ParserRule getNUMBER_LITERALRule() {
		return getNUMBER_LITERALAccess().getRule();
	}

	///* An upperbounded integer is used to define the upperbound of a collection multiplicity. The value may be the unlimited value. */
	//UPPER ecore::EInt:
	//	INT | '*';
	public BaseGrammarAccess.UPPERElements getUPPERAccess() {
		return gaBase.getUPPERAccess();
	}

	public ParserRule getUPPERRule() {
		return getUPPERAccess().getRule();
	}

	//URI:
	//	SINGLE_QUOTED_STRING;
	public BaseGrammarAccess.URIElements getURIAccess() {
		return gaBase.getURIAccess();
	}

	public ParserRule getURIRule() {
		return getURIAccess().getRule();
	}

	//terminal fragment ESCAPED_CHARACTER:
	//	'\\' ('b' | 't' | 'n' | 'f' | 'r' | 'u' | '"' | "'" | '\\');
	public TerminalRule getESCAPED_CHARACTERRule() {
		return gaBase.getESCAPED_CHARACTERRule();
	}

	//terminal fragment LETTER_CHARACTER:
	//	'a'..'z' | 'A'..'Z' | '_';
	public TerminalRule getLETTER_CHARACTERRule() {
		return gaBase.getLETTER_CHARACTERRule();
	}

	//terminal DOUBLE_QUOTED_STRING:
	//	'"' (ESCAPED_CHARACTER | !('\\' | '"'))* '"';
	public TerminalRule getDOUBLE_QUOTED_STRINGRule() {
		return gaBase.getDOUBLE_QUOTED_STRINGRule();
	}

	//terminal SINGLE_QUOTED_STRING:
	//	"'" (ESCAPED_CHARACTER | !('\\' | "'"))* "'";
	public TerminalRule getSINGLE_QUOTED_STRINGRule() {
		return gaBase.getSINGLE_QUOTED_STRINGRule();
	}

	//terminal ML_SINGLE_QUOTED_STRING:
	//	"/'"->"'/";
	public TerminalRule getML_SINGLE_QUOTED_STRINGRule() {
		return gaBase.getML_SINGLE_QUOTED_STRINGRule();
	}

	//terminal SIMPLE_ID:
	//	LETTER_CHARACTER (LETTER_CHARACTER | '0'..'9')*;
	public TerminalRule getSIMPLE_IDRule() {
		return gaBase.getSIMPLE_IDRule();
	}

	//terminal ESCAPED_ID:
	//	"_" SINGLE_QUOTED_STRING;
	public TerminalRule getESCAPED_IDRule() {
		return gaBase.getESCAPED_IDRule();
	}

	//terminal INT:
	//	'0'..'9'+;
	public TerminalRule getINTRule() {
		return gaBase.getINTRule();
	}

	//terminal ML_COMMENT:
	//	'/*'->'*/';
	public TerminalRule getML_COMMENTRule() {
		return gaBase.getML_COMMENTRule();
	}

	//terminal SL_COMMENT:
	//	'--' !('\n' | '\r')* ('\r'? '\n')?;
	public TerminalRule getSL_COMMENTRule() {
		return gaBase.getSL_COMMENTRule();
	}

	//terminal WS:
	//	' ' | '\t' | '\r' | '\n'+;
	public TerminalRule getWSRule() {
		return gaBase.getWSRule();
	}

	//terminal ANY_OTHER:
	//	.;
	public TerminalRule getANY_OTHERRule() {
		return gaBase.getANY_OTHERRule();
	}
}