/*******************************************************************************
 * Copyright (c) 2015 E.D.Willink and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     E.D.Willink - initial API and implementation
 *******************************************************************************
 * This code is 100% auto-generated
 * from: C:\GIT\org.eclipse.qvtd\plugins..\..\plugins\org.eclipse.qvtd.xtext.qvtimperative\src-gen\org\eclipse\qvtd\xtext\qvtimperative\QVTimperative.xtextbin
 * by: org.eclipse.ocl.examples.build.xtend.generateGrammar.xtend
 *
 * Do not edit it.
 *******************************************************************************/
package	org.eclipse.qvtd.xtext.qvtimperative;

import java.util.List;

import org.eclipse.emf.common.util.URI;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.ocl.xtext.base.utilities.AbstractGrammarResource;
import org.eclipse.xtext.AbstractMetamodelDeclaration;
import org.eclipse.xtext.AbstractRule;
import org.eclipse.xtext.Grammar;
import org.eclipse.xtext.ParserRule;
import org.eclipse.xtext.ReferencedMetamodel;
import org.eclipse.xtext.TerminalRule;
import org.eclipse.xtext.resource.XtextResourceSet;

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

/**
 * QVTimperativeGrammarResource provides a programmatically initialized org.eclipse.qvtd.xtext.qvtimperative.QVTimperative Grammar model avoiding
 * the speed limitations of the pre-Xtext 2.4 *.xmi models and the binary incompatibilities between differing *.xtextbin versions.
 * <p>
 * The grammar is immutable and is available as static INSTANCE and GRAMMAR fields.
 */
@SuppressWarnings("nls")
public class QVTimperativeGrammarResource extends AbstractGrammarResource
{
	private static final @NonNull Grammar G_QVTimperative = createGrammar("org.eclipse.qvtd.xtext.qvtimperative.QVTimperative");
	private static final @NonNull Grammar G_QVTcoreBase = createGrammar("org.eclipse.qvtd.xtext.qvtcorebase.QVTcoreBase");
	private static final @NonNull Grammar G_EssentialOCL = createGrammar("org.eclipse.ocl.xtext.essentialocl.EssentialOCL");
	private static final @NonNull Grammar G_Base = createGrammar("org.eclipse.ocl.xtext.base.Base");

	/**
	 *	The shared immutable instance of the org.eclipse.qvtd.xtext.qvtimperative.QVTimperative Grammar resource.
	 */
	public static final @NonNull QVTimperativeGrammarResource INSTANCE = new QVTimperativeGrammarResource();

	/**
	 *	The shared immutable instance of the org.eclipse.qvtd.xtext.qvtimperative.QVTimperative Grammar model.
	 */
	public static final @SuppressWarnings("null")@NonNull Grammar GRAMMAR = (Grammar)INSTANCE.getContents().get(0);

	/**
	 *	The name of the language supported by this grammar.
	 */
	public static final @NonNull String LANGUAGE_NAME = "org.eclipse.qvtd.xtext.qvtimperative.QVTimperative";

	protected QVTimperativeGrammarResource() {
		super(URI.createURI(LANGUAGE_NAME));
		List<EObject> contents = getContents();
		contents.add(_QVTimperative.initGrammar());
		contents.add(_QVTcoreBase.initGrammar());
		contents.add(_EssentialOCL.initGrammar());
		contents.add(_Base.initGrammar());
	}

	/*
	 * This class should be bound to org.eclipse.xtext.service.GrammarProvider.
	 */ 
	@Singleton
	public static class GrammarProvider extends org.eclipse.xtext.service.GrammarProvider
	{
		@Inject
		public GrammarProvider(Provider<XtextResourceSet> resourceSetProvider) {
			super(LANGUAGE_NAME, resourceSetProvider);
		}

		@Override
		public Grammar getGrammar(Object requestor) {
			return QVTimperativeGrammarResource.GRAMMAR;
		}
	}
	
	private static class _QVTimperative
	{
		private static final @NonNull ReferencedMetamodel MM = createReferencedMetamodel(org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.eINSTANCE, null); // http://www.eclipse.org/qvt/2015/QVTimperativeCS
		private static final @NonNull ReferencedMetamodel MM_base = createReferencedMetamodel(org.eclipse.ocl.xtext.basecs.BaseCSPackage.eINSTANCE, "base"); // http://www.eclipse.org/ocl/2015/BaseCS
		private static final @NonNull ReferencedMetamodel MM_ecore = createReferencedMetamodel(org.eclipse.emf.ecore.EcorePackage.eINSTANCE, "ecore"); // http://www.eclipse.org/emf/2002/Ecore
		private static final @NonNull ReferencedMetamodel MM_essentialocl = createReferencedMetamodel(org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.eINSTANCE, "essentialocl"); // http://www.eclipse.org/ocl/2015/EssentialOCLCS
		private static final @NonNull ReferencedMetamodel MM_pivot = createReferencedMetamodel(org.eclipse.ocl.pivot.PivotPackage.eINSTANCE, "pivot"); // http://www.eclipse.org/ocl/2015/Pivot
		private static final @NonNull ReferencedMetamodel MM_qvtbase = createReferencedMetamodel(org.eclipse.qvtd.pivot.qvtbase.QVTbasePackage.eINSTANCE, "qvtbase"); // http://www.eclipse.org/qvt/2015/QVTbase
		private static final @NonNull ReferencedMetamodel MM_qvtcorebase = createReferencedMetamodel(org.eclipse.qvtd.pivot.qvtcorebase.QVTcoreBasePackage.eINSTANCE, "qvtcorebase"); // http://www.eclipse.org/qvt/2015/QVTcoreBase
		private static final @NonNull ReferencedMetamodel MM_qvtcorebasecs = createReferencedMetamodel(org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.eINSTANCE, "qvtcorebasecs"); // http://www.eclipse.org/qvt/2015/QVTcoreBaseCS
		private static final @NonNull ReferencedMetamodel MM_qvtimperative = createReferencedMetamodel(org.eclipse.qvtd.pivot.qvtimperative.QVTimperativePackage.eINSTANCE, "qvtimperative"); // http://www.eclipse.org/qvt/2015/QVTimperative
		
		private static final @NonNull ParserRule PR_DirectionCS = createParserRule("DirectionCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DIRECTION_CS));
		private static final @NonNull ParserRule PR_MappingCS = createParserRule("MappingCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.MAPPING_CS));
		private static final @NonNull ParserRule PR_MappingCallBindingCS = createParserRule("MappingCallBindingCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.MAPPING_CALL_BINDING_CS));
		private static final @NonNull ParserRule PR_MappingCallCS = createParserRule("MappingCallCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.MAPPING_CALL_CS));
		private static final @NonNull ParserRule PR_MappingIteratorCS = createParserRule("MappingIteratorCS", createTypeRef(MM_essentialocl, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.VARIABLE_CS));
		private static final @NonNull ParserRule PR_MappingLoopCS = createParserRule("MappingLoopCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.MAPPING_LOOP_CS));
		private static final @NonNull ParserRule PR_MappingSequenceCS = createParserRule("MappingSequenceCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.MAPPING_SEQUENCE_CS));
		private static final @NonNull ParserRule PR_MappingStatementCS = createParserRule("MappingStatementCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.MAPPING_STATEMENT_CS));
		private static final @NonNull ParserRule PR_MiddleBottomPatternCS = createParserRule("MiddleBottomPatternCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.BOTTOM_PATTERN_CS));
		private static final @NonNull ParserRule PR_MiddleDomainCS = createParserRule("MiddleDomainCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DOMAIN_CS));
		private static final @NonNull ParserRule PR_MiddleGuardPatternCS = createParserRule("MiddleGuardPatternCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS));
		private static final @NonNull ParserRule PR_SourceBottomPatternCS = createParserRule("SourceBottomPatternCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.BOTTOM_PATTERN_CS));
		private static final @NonNull ParserRule PR_SourceDomainCS = createParserRule("SourceDomainCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DOMAIN_CS));
		private static final @NonNull ParserRule PR_SourceGuardPatternCS = createParserRule("SourceGuardPatternCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS));
		private static final @NonNull ParserRule PR_TargetBottomPatternCS = createParserRule("TargetBottomPatternCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.BOTTOM_PATTERN_CS));
		private static final @NonNull ParserRule PR_TargetDomainCS = createParserRule("TargetDomainCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DOMAIN_CS));
		private static final @NonNull ParserRule PR_TargetGuardPatternCS = createParserRule("TargetGuardPatternCS", createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS));
		private static final @NonNull ParserRule PR_TopLevelCS = createParserRule("TopLevelCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.TOP_LEVEL_CS));
		
		private static void initParserRules() {
			PR_DirectionCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DIRECTION_CS)), createAssignment("name", "=", createRuleCall(_QVTcoreBase.PR_UnrestrictedName)), setCardinality("?", createGroup(createKeyword("imports"), createAssignment("imports", "+=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.PACKAGE), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), setCardinality("*", createGroup(createKeyword(","), createAssignment("imports", "+=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.PACKAGE), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))))))), setCardinality("?", createGroup(createKeyword("uses"), createAssignment("uses", "+=", createCrossReference(createTypeRef(MM_qvtcorebase, org.eclipse.qvtd.pivot.qvtcorebase.QVTcoreBasePackage.Literals.CORE_DOMAIN), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), setCardinality("*", createGroup(createKeyword(","), createAssignment("uses", "+=", createCrossReference(createTypeRef(MM_qvtcorebase, org.eclipse.qvtd.pivot.qvtcorebase.QVTcoreBasePackage.Literals.CORE_DOMAIN), createRuleCall(_QVTcoreBase.PR_UnrestrictedName)))))))));
			PR_MappingCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.MAPPING_CS)), createKeyword("map"), createAssignment("name", "=", createRuleCall(_QVTcoreBase.PR_UnrestrictedName)), setCardinality("?", createGroup(createKeyword("in"), createAssignment("in", "=", createCrossReference(createTypeRef(MM_qvtbase, org.eclipse.qvtd.pivot.qvtbase.QVTbasePackage.Literals.TRANSFORMATION), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))))), createKeyword("{"), setCardinality("*", createAssignment("ownedDomains", "+=", createAlternatives(createRuleCall(PR_SourceDomainCS), createRuleCall(PR_TargetDomainCS)))), setCardinality("?", createGroup(createKeyword("where"), createAssignment("ownedMiddle", "=", createRuleCall(PR_MiddleDomainCS)))), setCardinality("?", createAssignment("ownedMappingSequence", "=", createRuleCall(PR_MappingSequenceCS))), createKeyword("}")));
			PR_MappingCallBindingCS.setAlternatives(createGroup(createAssignment("referredVariable", "=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.VARIABLE), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), createKeyword(":="), createAssignment("ownedValue", "=", createRuleCall(_EssentialOCL.PR_ExpCS)), createKeyword(";")));
			PR_MappingCallCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.qvtd.xtext.qvtimperativecs.QVTimperativeCSPackage.Literals.MAPPING_CALL_CS)), createKeyword("call"), createAssignment("referredMapping", "=", createCrossReference(createTypeRef(MM_qvtimperative, org.eclipse.qvtd.pivot.qvtimperative.QVTimperativePackage.Literals.MAPPING), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), createKeyword("{"), setCardinality("*", createAssignment("ownedBindings", "+=", createRuleCall(PR_MappingCallBindingCS))), createKeyword("}")));
			PR_MappingIteratorCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(_QVTcoreBase.PR_UnrestrictedName)), setCardinality("?", createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(_EssentialOCL.PR_TypeExpCS))))));
			PR_MappingLoopCS.setAlternatives(createGroup(createKeyword("for"), createAssignment("ownedIterator", "=", createRuleCall(PR_MappingIteratorCS)), createKeyword("in"), createAssignment("ownedInExpression", "=", createRuleCall(_EssentialOCL.PR_ExpCS)), createKeyword("{"), createAssignment("ownedMappingSequence", "=", createRuleCall(PR_MappingSequenceCS)), createKeyword("}")));
			PR_MappingSequenceCS.setAlternatives(setCardinality("+", createAssignment("ownedMappingStatements", "+=", createRuleCall(PR_MappingStatementCS))));
			PR_MappingStatementCS.setAlternatives(createAlternatives(createRuleCall(PR_MappingCallCS), createRuleCall(PR_MappingLoopCS)));
			PR_MiddleBottomPatternCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.BOTTOM_PATTERN_CS)), createKeyword("{"), setCardinality("*", createAssignment("ownedConstraints", "+=", createRuleCall(_QVTcoreBase.PR_PredicateOrAssignmentCS))), createKeyword("}")));
			PR_MiddleDomainCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DOMAIN_CS)), createAssignment("ownedGuardPattern", "=", createRuleCall(PR_MiddleGuardPatternCS)), createAssignment("ownedBottomPattern", "=", createRuleCall(PR_MiddleBottomPatternCS))));
			PR_MiddleGuardPatternCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS)), createKeyword("("), setCardinality("*", createAssignment("ownedPredicates", "+=", createRuleCall(_QVTcoreBase.PR_PredicateCS))), createKeyword(")")));
			PR_SourceBottomPatternCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.BOTTOM_PATTERN_CS)), createKeyword("{"), createKeyword("}")));
			PR_SourceDomainCS.setAlternatives(createGroup(createAssignment("isCheck", "?=", createKeyword("check")), createAssignment("direction", "=", createCrossReference(createTypeRef(MM_qvtbase, org.eclipse.qvtd.pivot.qvtbase.QVTbasePackage.Literals.TYPED_MODEL), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), createAssignment("ownedGuardPattern", "=", createRuleCall(PR_SourceGuardPatternCS)), createAssignment("ownedBottomPattern", "=", createRuleCall(PR_SourceBottomPatternCS))));
			PR_SourceGuardPatternCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS)), createKeyword("("), setCardinality("?", createGroup(createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(_QVTcoreBase.PR_UnrealizedVariableCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(_QVTcoreBase.PR_UnrealizedVariableCS)))))), createKeyword(")")));
			PR_TargetBottomPatternCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.BOTTOM_PATTERN_CS)), createKeyword("{"), setCardinality("?", createGroup(createAlternatives(createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(_QVTcoreBase.PR_UnrealizedVariableCS)), createAssignment("ownedRealizedVariables", "+=", createRuleCall(_QVTcoreBase.PR_RealizedVariableCS))), setCardinality("*", createGroup(createKeyword(","), createAlternatives(createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(_QVTcoreBase.PR_UnrealizedVariableCS)), createAssignment("ownedRealizedVariables", "+=", createRuleCall(_QVTcoreBase.PR_RealizedVariableCS))))))), createKeyword("}")));
			PR_TargetDomainCS.setAlternatives(createGroup(createAssignment("isEnforce", "?=", createKeyword("enforce")), createAssignment("direction", "=", createCrossReference(createTypeRef(MM_qvtbase, org.eclipse.qvtd.pivot.qvtbase.QVTbasePackage.Literals.TYPED_MODEL), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), createAssignment("ownedGuardPattern", "=", createRuleCall(PR_TargetGuardPatternCS)), createAssignment("ownedBottomPattern", "=", createRuleCall(PR_TargetBottomPatternCS))));
			PR_TargetGuardPatternCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM_qvtcorebasecs, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS)), createKeyword("("), setCardinality("?", createGroup(createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(_QVTcoreBase.PR_UnrealizedVariableCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(_QVTcoreBase.PR_UnrealizedVariableCS)))))), createKeyword(")")));
			PR_TopLevelCS.setAlternatives(createGroup(setCardinality("*", createAlternatives(createAssignment("ownedImports", "+=", createRuleCall(_QVTcoreBase.PR_ImportCS)), createAssignment("ownedLibraries", "+=", createRuleCall(_QVTcoreBase.PR_LibraryCS)))), setCardinality("*", createAlternatives(createAssignment("ownedTransformations", "+=", createRuleCall(_QVTcoreBase.PR_TransformationCS)), createAssignment("ownedMappings", "+=", createRuleCall(PR_MappingCS)), createAssignment("ownedQueries", "+=", createRuleCall(_QVTcoreBase.PR_QueryCS))))));
		}
		
		private static @NonNull Grammar initGrammar() {
			initParserRules();
			Grammar grammar = G_QVTimperative;
			{
				List<AbstractMetamodelDeclaration> metamodelDeclarations = grammar.getMetamodelDeclarations();
				metamodelDeclarations.add(MM_ecore);
				metamodelDeclarations.add(MM_base);
				metamodelDeclarations.add(MM_essentialocl);
				metamodelDeclarations.add(MM_pivot);
				metamodelDeclarations.add(MM_qvtbase);
				metamodelDeclarations.add(MM_qvtcorebase);
				metamodelDeclarations.add(MM_qvtimperative);
				metamodelDeclarations.add(MM_qvtcorebasecs);
				metamodelDeclarations.add(MM);
			}
			{
				List<AbstractRule> rules = grammar.getRules();
				rules.add(PR_TopLevelCS);
				rules.add(PR_DirectionCS);
				rules.add(PR_MappingCS);
				rules.add(PR_MappingCallCS);
				rules.add(PR_MappingCallBindingCS);
				rules.add(PR_MappingLoopCS);
				rules.add(PR_MappingIteratorCS);
				rules.add(PR_MappingSequenceCS);
				rules.add(PR_MappingStatementCS);
				rules.add(PR_SourceDomainCS);
				rules.add(PR_SourceBottomPatternCS);
				rules.add(PR_SourceGuardPatternCS);
				rules.add(PR_MiddleDomainCS);
				rules.add(PR_MiddleBottomPatternCS);
				rules.add(PR_MiddleGuardPatternCS);
				rules.add(PR_TargetDomainCS);
				rules.add(PR_TargetBottomPatternCS);
				rules.add(PR_TargetGuardPatternCS);
			}
			{
				List<Grammar> usedGrammars = grammar.getUsedGrammars();
				usedGrammars.add(G_QVTcoreBase);
			}
			return grammar;
		}
	}
	
	private static class _QVTcoreBase
	{
		private static final @NonNull ReferencedMetamodel MM = createReferencedMetamodel(org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.eINSTANCE, null); // http://www.eclipse.org/qvt/2015/QVTcoreBaseCS
		private static final @NonNull ReferencedMetamodel MM_base = createReferencedMetamodel(org.eclipse.ocl.xtext.basecs.BaseCSPackage.eINSTANCE, "base"); // http://www.eclipse.org/ocl/2015/BaseCS
		private static final @NonNull ReferencedMetamodel MM_ecore = createReferencedMetamodel(org.eclipse.emf.ecore.EcorePackage.eINSTANCE, "ecore"); // http://www.eclipse.org/emf/2002/Ecore
		private static final @NonNull ReferencedMetamodel MM_essentialocl = createReferencedMetamodel(org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.eINSTANCE, "essentialocl"); // http://www.eclipse.org/ocl/2015/EssentialOCLCS
		private static final @NonNull ReferencedMetamodel MM_pivot = createReferencedMetamodel(org.eclipse.ocl.pivot.PivotPackage.eINSTANCE, "pivot"); // http://www.eclipse.org/ocl/2015/Pivot
		private static final @NonNull ReferencedMetamodel MM_qvtbase = createReferencedMetamodel(org.eclipse.qvtd.pivot.qvtbase.QVTbasePackage.eINSTANCE, "qvtbase"); // http://www.eclipse.org/qvt/2015/QVTbase
		private static final @NonNull ReferencedMetamodel MM_qvtcorebase = createReferencedMetamodel(org.eclipse.qvtd.pivot.qvtcorebase.QVTcoreBasePackage.eINSTANCE, "qvtcorebase"); // http://www.eclipse.org/qvt/2015/QVTcoreBase
		
		private static final @NonNull ParserRule PR_BottomPatternCS = createParserRule("BottomPatternCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.BOTTOM_PATTERN_CS));
		private static final @NonNull ParserRule PR_DirectionCS = createParserRule("DirectionCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DIRECTION_CS));
		private static final @NonNull ParserRule PR_GuardPatternCS = createParserRule("GuardPatternCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS));
		private static final @NonNull ParserRule PR_GuardVariableCS = createParserRule("GuardVariableCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.UNREALIZED_VARIABLE_CS));
		private static final @NonNull ParserRule PR_ImportCS = createParserRule("ImportCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.IMPORT_CS));
		private static final @NonNull ParserRule PR_LibraryCS = createParserRule("LibraryCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.LIBRARY_CS));
		private static final @NonNull ParserRule PR_NamedDomainCS = createParserRule("NamedDomainCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DOMAIN_CS));
		private static final @NonNull ParserRule PR_ParamDeclarationCS = createParserRule("ParamDeclarationCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.PARAM_DECLARATION_CS));
		private static final @NonNull ParserRule PR_PredicateCS = createParserRule("PredicateCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.PREDICATE_CS));
		private static final @NonNull ParserRule PR_PredicateOrAssignmentCS = createParserRule("PredicateOrAssignmentCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.PREDICATE_OR_ASSIGNMENT_CS));
		private static final @NonNull ParserRule PR_QueryCS = createParserRule("QueryCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.QUERY_CS));
		private static final @NonNull ParserRule PR_RealizedVariableCS = createParserRule("RealizedVariableCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.REALIZED_VARIABLE_CS));
		private static final @NonNull ParserRule PR_ScopeNameCS = createParserRule("ScopeNameCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.PATH_NAME_CS));
		private static final @NonNull ParserRule PR_TransformationCS = createParserRule("TransformationCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.TRANSFORMATION_CS));
		private static final @NonNull ParserRule PR_UnnamedDomainCS = createParserRule("UnnamedDomainCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DOMAIN_CS));
		private static final @NonNull ParserRule PR_UnrealizedVariableCS = createParserRule("UnrealizedVariableCS", createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.UNREALIZED_VARIABLE_CS));
		private static final @NonNull ParserRule PR_UnrestrictedName = createParserRule("UnrestrictedName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		
		private static void initParserRules() {
			PR_BottomPatternCS.setAlternatives(createAlternatives(createGroup(createKeyword("{"), createAlternatives(createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(PR_UnrealizedVariableCS)), createAssignment("ownedRealizedVariables", "+=", createRuleCall(PR_RealizedVariableCS))), setCardinality("*", createGroup(createKeyword(","), createAlternatives(createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(PR_UnrealizedVariableCS)), createAssignment("ownedRealizedVariables", "+=", createRuleCall(PR_RealizedVariableCS))))), setCardinality("?", createGroup(createKeyword("|"), setCardinality("*", createAssignment("ownedConstraints", "+=", createRuleCall(PR_PredicateOrAssignmentCS))))), createKeyword("}")), createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.BOTTOM_PATTERN_CS)), createKeyword("{"), setCardinality("*", createAssignment("ownedConstraints", "+=", createRuleCall(PR_PredicateOrAssignmentCS))), createKeyword("}"))));
			PR_DirectionCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DIRECTION_CS)), setCardinality("?", createAssignment("name", "=", createRuleCall(PR_UnrestrictedName))), setCardinality("?", createGroup(createKeyword("imports"), createAssignment("imports", "+=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.PACKAGE), createRuleCall(PR_UnrestrictedName))), setCardinality("*", createGroup(createKeyword(","), createAssignment("imports", "+=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.PACKAGE), createRuleCall(PR_UnrestrictedName))))))), setCardinality("?", createGroup(createKeyword("uses"), createAssignment("uses", "+=", createCrossReference(createTypeRef(MM_qvtcorebase, org.eclipse.qvtd.pivot.qvtcorebase.QVTcoreBasePackage.Literals.CORE_DOMAIN), createRuleCall(PR_UnrestrictedName))), setCardinality("*", createGroup(createKeyword(","), createAssignment("uses", "+=", createCrossReference(createTypeRef(MM_qvtcorebase, org.eclipse.qvtd.pivot.qvtcorebase.QVTcoreBasePackage.Literals.CORE_DOMAIN), createRuleCall(PR_UnrestrictedName)))))))));
			PR_GuardPatternCS.setAlternatives(createAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS)), createKeyword("("), setCardinality("?", createGroup(createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(PR_GuardVariableCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(PR_GuardVariableCS)))))), setCardinality("?", createGroup(createKeyword("|"), setCardinality("*", createAssignment("ownedPredicates", "+=", createRuleCall(PR_PredicateCS))))), createKeyword(")")), createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS)), createKeyword("("), setCardinality("?", createGroup(createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(PR_GuardVariableCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedUnrealizedVariables", "+=", createRuleCall(PR_GuardVariableCS)))))), createKeyword(")")), createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.GUARD_PATTERN_CS)), createKeyword("("), setCardinality("*", createAssignment("ownedPredicates", "+=", createRuleCall(PR_PredicateCS))), createKeyword(")"))));
			PR_GuardVariableCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(PR_UnrestrictedName)), createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(_EssentialOCL.PR_TypeExpCS))));
			PR_ImportCS.setAlternatives(createGroup(createKeyword("import"), setCardinality("?", createGroup(createAssignment("name", "=", createRuleCall(_Base.PR_Identifier)), createKeyword(":"))), createAssignment("ownedPathName", "=", createRuleCall(_EssentialOCL.PR_URIPathNameCS)), setCardinality("?", createGroup(createAssignment("isAll", "?=", createKeyword("::")), createKeyword("*"))), createKeyword(";")));
			PR_LibraryCS.setAlternatives(createGroup(createKeyword("library"), createAssignment("referredPackage", "=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.PACKAGE), createRuleCall(_Base.PR_URI))), createKeyword(";")));
			PR_NamedDomainCS.setAlternatives(createGroup(setCardinality("?", createAssignment("isCheck", "?=", createKeyword("check"))), setCardinality("?", createAssignment("isEnforce", "?=", createKeyword("enforce"))), createAssignment("direction", "=", createCrossReference(createTypeRef(MM_qvtbase, org.eclipse.qvtd.pivot.qvtbase.QVTbasePackage.Literals.TYPED_MODEL), createRuleCall(PR_UnrestrictedName))), createAssignment("ownedGuardPattern", "=", createRuleCall(PR_GuardPatternCS)), createAssignment("ownedBottomPattern", "=", createRuleCall(PR_BottomPatternCS))));
			PR_ParamDeclarationCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(PR_UnrestrictedName)), createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(_EssentialOCL.PR_TypeExpCS))));
			PR_PredicateCS.setAlternatives(createGroup(createAssignment("ownedCondition", "=", createRuleCall(_EssentialOCL.PR_ExpCS)), createKeyword(";")));
			PR_PredicateOrAssignmentCS.setAlternatives(createGroup(setCardinality("?", createAssignment("isDefault", "?=", createKeyword("default"))), createAssignment("ownedTarget", "=", createRuleCall(_EssentialOCL.PR_ExpCS)), setCardinality("?", createGroup(createKeyword(":="), createAssignment("ownedInitExpression", "=", createRuleCall(_EssentialOCL.PR_ExpCS)))), createKeyword(";")));
			PR_QueryCS.setAlternatives(createGroup(createKeyword("query"), createAssignment("ownedPathName", "=", createRuleCall(PR_ScopeNameCS)), createAssignment("name", "=", createRuleCall(PR_UnrestrictedName)), createKeyword("("), setCardinality("?", createGroup(createAssignment("ownedParameters", "+=", createRuleCall(PR_ParamDeclarationCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedParameters", "+=", createRuleCall(PR_ParamDeclarationCS)))))), createKeyword(")"), createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(_EssentialOCL.PR_TypeExpCS)), createAlternatives(createKeyword(";"), createGroup(createKeyword("{"), createAssignment("ownedExpression", "=", createRuleCall(_EssentialOCL.PR_ExpCS)), createKeyword("}")))));
			PR_RealizedVariableCS.setAlternatives(createGroup(createKeyword("realize"), createAssignment("name", "=", createRuleCall(PR_UnrestrictedName)), createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(_EssentialOCL.PR_TypeExpCS))));
			PR_ScopeNameCS.setAlternatives(createGroup(createAssignment("ownedPathElements", "+=", createRuleCall(_Base.PR_FirstPathElementCS)), createKeyword("::"), setCardinality("*", createGroup(createAssignment("ownedPathElements", "+=", createRuleCall(_Base.PR_NextPathElementCS)), createKeyword("::")))));
			PR_TransformationCS.setAlternatives(createGroup(createKeyword("transformation"), setCardinality("?", createAssignment("ownedPathName", "=", createRuleCall(PR_ScopeNameCS))), createAssignment("name", "=", createRuleCall(_EssentialOCL.PR_UnreservedName)), createKeyword("{"), setCardinality("*", createGroup(createAssignment("ownedDirections", "+=", createRuleCall(_QVTimperative.PR_DirectionCS)), createKeyword(";"))), createKeyword("}")));
			PR_UnnamedDomainCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.qvtd.xtext.qvtcorebasecs.QVTcoreBaseCSPackage.Literals.DOMAIN_CS)), createAssignment("ownedGuardPattern", "=", createRuleCall(PR_GuardPatternCS)), createAssignment("ownedBottomPattern", "=", createRuleCall(PR_BottomPatternCS))));
			PR_UnrealizedVariableCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(PR_UnrestrictedName)), setCardinality("?", createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(_EssentialOCL.PR_TypeExpCS)))), setCardinality("?", createGroup(createKeyword(":="), createAssignment("ownedInitExpression", "=", createRuleCall(_EssentialOCL.PR_ExpCS))))));
			PR_UnrestrictedName.setAlternatives(createAlternatives(createRuleCall(_EssentialOCL.PR_EssentialOCLUnrestrictedName), createKeyword("check"), createKeyword("enforce"), createKeyword("import"), createKeyword("imports"), createKeyword("library"), createKeyword("map"), createKeyword("query"), createKeyword("realize"), createKeyword("refines"), createKeyword("transformation"), createKeyword("uses")));
		}
		
		private static @NonNull Grammar initGrammar() {
			initParserRules();
			Grammar grammar = G_QVTcoreBase;
			{
				List<AbstractMetamodelDeclaration> metamodelDeclarations = grammar.getMetamodelDeclarations();
				metamodelDeclarations.add(MM_ecore);
				metamodelDeclarations.add(MM_base);
				metamodelDeclarations.add(MM_essentialocl);
				metamodelDeclarations.add(MM_pivot);
				metamodelDeclarations.add(MM_qvtbase);
				metamodelDeclarations.add(MM_qvtcorebase);
				metamodelDeclarations.add(MM);
			}
			{
				List<AbstractRule> rules = grammar.getRules();
				rules.add(PR_BottomPatternCS);
				rules.add(PR_DirectionCS);
				rules.add(PR_GuardPatternCS);
				rules.add(PR_GuardVariableCS);
				rules.add(PR_ImportCS);
				rules.add(PR_LibraryCS);
				rules.add(PR_NamedDomainCS);
				rules.add(PR_ParamDeclarationCS);
				rules.add(PR_PredicateCS);
				rules.add(PR_PredicateOrAssignmentCS);
				rules.add(PR_QueryCS);
				rules.add(PR_ScopeNameCS);
				rules.add(PR_TransformationCS);
				rules.add(PR_UnrealizedVariableCS);
				rules.add(PR_RealizedVariableCS);
				rules.add(PR_UnnamedDomainCS);
				rules.add(PR_UnrestrictedName);
			}
			{
				List<Grammar> usedGrammars = grammar.getUsedGrammars();
				usedGrammars.add(G_EssentialOCL);
			}
			return grammar;
		}
	}
	
	private static class _EssentialOCL
	{
		private static final @NonNull ReferencedMetamodel MM = createReferencedMetamodel(org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.eINSTANCE, null); // http://www.eclipse.org/ocl/2015/EssentialOCLCS
		private static final @NonNull ReferencedMetamodel MM_base = createReferencedMetamodel(org.eclipse.ocl.xtext.basecs.BaseCSPackage.eINSTANCE, "base"); // http://www.eclipse.org/ocl/2015/BaseCS
		private static final @NonNull ReferencedMetamodel MM_ecore = createReferencedMetamodel(org.eclipse.emf.ecore.EcorePackage.eINSTANCE, "ecore"); // http://www.eclipse.org/emf/2002/Ecore
		private static final @NonNull ReferencedMetamodel MM_pivot = createReferencedMetamodel(org.eclipse.ocl.pivot.PivotPackage.eINSTANCE, "pivot"); // http://www.eclipse.org/ocl/2015/Pivot
		
		private static final @NonNull ParserRule PR_BinaryOperatorName = createParserRule("BinaryOperatorName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_BooleanLiteralExpCS = createParserRule("BooleanLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.BOOLEAN_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_CollectionLiteralExpCS = createParserRule("CollectionLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.COLLECTION_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_CollectionLiteralPartCS = createParserRule("CollectionLiteralPartCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.COLLECTION_LITERAL_PART_CS));
		private static final @NonNull ParserRule PR_CollectionPatternCS = createParserRule("CollectionPatternCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.COLLECTION_PATTERN_CS));
		private static final @NonNull ParserRule PR_CollectionTypeCS = createParserRule("CollectionTypeCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.COLLECTION_TYPE_CS));
		private static final @NonNull ParserRule PR_CollectionTypeIdentifier = createParserRule("CollectionTypeIdentifier", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_ConstructorPartCS = createParserRule("ConstructorPartCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.CONSTRUCTOR_PART_CS));
		private static final @NonNull ParserRule PR_CurlyBracketedClauseCS = createParserRule("CurlyBracketedClauseCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.CURLY_BRACKETED_CLAUSE_CS));
		private static final @NonNull ParserRule PR_ElseIfThenExpCS = createParserRule("ElseIfThenExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.IF_THEN_EXP_CS));
		private static final @NonNull ParserRule PR_EssentialOCLInfixOperatorName = createParserRule("EssentialOCLInfixOperatorName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_EssentialOCLNavigationOperatorName = createParserRule("EssentialOCLNavigationOperatorName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_EssentialOCLReservedKeyword = createParserRule("EssentialOCLReservedKeyword", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_EssentialOCLUnaryOperatorName = createParserRule("EssentialOCLUnaryOperatorName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_EssentialOCLUnreservedName = createParserRule("EssentialOCLUnreservedName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_EssentialOCLUnrestrictedName = createParserRule("EssentialOCLUnrestrictedName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_ExpCS = createParserRule("ExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.EXP_CS));
		private static final @NonNull ParserRule PR_IfExpCS = createParserRule("IfExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.IF_EXP_CS));
		private static final @NonNull ParserRule PR_InfixOperatorName = createParserRule("InfixOperatorName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_InvalidLiteralExpCS = createParserRule("InvalidLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.INVALID_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_LambdaLiteralExpCS = createParserRule("LambdaLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.LAMBDA_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_LetExpCS = createParserRule("LetExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.LET_EXP_CS));
		private static final @NonNull ParserRule PR_LetVariableCS = createParserRule("LetVariableCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.LET_VARIABLE_CS));
		private static final @NonNull ParserRule PR_Model = createParserRule("Model", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.CONTEXT_CS));
		private static final @NonNull ParserRule PR_NameExpCS = createParserRule("NameExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NAME_EXP_CS));
		private static final @NonNull ParserRule PR_NavigatingArgCS = createParserRule("NavigatingArgCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NAVIGATING_ARG_CS));
		private static final @NonNull ParserRule PR_NavigatingArgExpCS = createParserRule("NavigatingArgExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.EXP_CS));
		private static final @NonNull ParserRule PR_NavigatingBarArgCS = createParserRule("NavigatingBarArgCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NAVIGATING_ARG_CS));
		private static final @NonNull ParserRule PR_NavigatingCommaArgCS = createParserRule("NavigatingCommaArgCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NAVIGATING_ARG_CS));
		private static final @NonNull ParserRule PR_NavigatingSemiArgCS = createParserRule("NavigatingSemiArgCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NAVIGATING_ARG_CS));
		private static final @NonNull ParserRule PR_NavigationOperatorName = createParserRule("NavigationOperatorName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_NestedExpCS = createParserRule("NestedExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NESTED_EXP_CS));
		private static final @NonNull ParserRule PR_NullLiteralExpCS = createParserRule("NullLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NULL_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_NumberLiteralExpCS = createParserRule("NumberLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NUMBER_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_PatternExpCS = createParserRule("PatternExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.PATTERN_EXP_CS));
		private static final @NonNull ParserRule PR_PrefixedLetExpCS = createParserRule("PrefixedLetExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.EXP_CS));
		private static final @NonNull ParserRule PR_PrefixedPrimaryExpCS = createParserRule("PrefixedPrimaryExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.EXP_CS));
		private static final @NonNull ParserRule PR_PrimaryExpCS = createParserRule("PrimaryExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.EXP_CS));
		private static final @NonNull ParserRule PR_PrimitiveLiteralExpCS = createParserRule("PrimitiveLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.PRIMITIVE_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_PrimitiveTypeCS = createParserRule("PrimitiveTypeCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.PRIMITIVE_TYPE_REF_CS));
		private static final @NonNull ParserRule PR_PrimitiveTypeIdentifier = createParserRule("PrimitiveTypeIdentifier", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_RoundBracketedClauseCS = createParserRule("RoundBracketedClauseCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.ROUND_BRACKETED_CLAUSE_CS));
		private static final @NonNull ParserRule PR_SelfExpCS = createParserRule("SelfExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.SELF_EXP_CS));
		private static final @NonNull ParserRule PR_SquareBracketedClauseCS = createParserRule("SquareBracketedClauseCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.SQUARE_BRACKETED_CLAUSE_CS));
		private static final @NonNull ParserRule PR_StringLiteralExpCS = createParserRule("StringLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.STRING_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_TupleLiteralExpCS = createParserRule("TupleLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.TUPLE_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_TupleLiteralPartCS = createParserRule("TupleLiteralPartCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.TUPLE_LITERAL_PART_CS));
		private static final @NonNull ParserRule PR_TuplePartCS = createParserRule("TuplePartCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TUPLE_PART_CS));
		private static final @NonNull ParserRule PR_TupleTypeCS = createParserRule("TupleTypeCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TUPLE_TYPE_CS));
		private static final @NonNull ParserRule PR_TypeExpCS = createParserRule("TypeExpCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TYPED_REF_CS));
		private static final @NonNull ParserRule PR_TypeLiteralCS = createParserRule("TypeLiteralCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TYPED_REF_CS));
		private static final @NonNull ParserRule PR_TypeLiteralExpCS = createParserRule("TypeLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.TYPE_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_TypeLiteralWithMultiplicityCS = createParserRule("TypeLiteralWithMultiplicityCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TYPED_REF_CS));
		private static final @NonNull ParserRule PR_TypeNameExpCS = createParserRule("TypeNameExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.TYPE_NAME_EXP_CS));
		private static final @NonNull ParserRule PR_URIFirstPathElementCS = createParserRule("URIFirstPathElementCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.PATH_ELEMENT_CS));
		private static final @NonNull ParserRule PR_URIPathNameCS = createParserRule("URIPathNameCS", createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.PATH_NAME_CS));
		private static final @NonNull ParserRule PR_UnaryOperatorName = createParserRule("UnaryOperatorName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_UnlimitedNaturalLiteralExpCS = createParserRule("UnlimitedNaturalLiteralExpCS", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.UNLIMITED_NATURAL_LITERAL_EXP_CS));
		private static final @NonNull ParserRule PR_UnreservedName = createParserRule("UnreservedName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_UnrestrictedName = createParserRule("UnrestrictedName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		
		private static void initParserRules() {
			PR_BinaryOperatorName.setAlternatives(createAlternatives(createRuleCall(PR_InfixOperatorName), createRuleCall(PR_NavigationOperatorName)));
			PR_BooleanLiteralExpCS.setAlternatives(createAlternatives(createAssignment("symbol", "=", createKeyword("true")), createAssignment("symbol", "=", createKeyword("false"))));
			PR_CollectionLiteralExpCS.setAlternatives(createGroup(createAssignment("ownedType", "=", createRuleCall(PR_CollectionTypeCS)), createKeyword("{"), setCardinality("?", createGroup(createAssignment("ownedParts", "+=", createRuleCall(PR_CollectionLiteralPartCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedParts", "+=", createRuleCall(PR_CollectionLiteralPartCS)))))), createKeyword("}")));
			PR_CollectionLiteralPartCS.setAlternatives(createAlternatives(createGroup(createAssignment("ownedExpression", "=", createRuleCall(PR_ExpCS)), setCardinality("?", createGroup(createKeyword(".."), createAssignment("ownedLastExpression", "=", createRuleCall(PR_ExpCS))))), createAssignment("ownedExpression", "=", createRuleCall(PR_PatternExpCS))));
			PR_CollectionPatternCS.setAlternatives(createGroup(createAssignment("ownedType", "=", createRuleCall(PR_CollectionTypeCS)), createKeyword("{"), setCardinality("?", createGroup(createAssignment("ownedParts", "+=", createRuleCall(PR_PatternExpCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedParts", "+=", createRuleCall(PR_PatternExpCS)))), createGroup(createKeyword("++"), createAssignment("restVariableName", "=", createRuleCall(_Base.PR_Identifier))))), createKeyword("}")));
			PR_CollectionTypeCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(PR_CollectionTypeIdentifier)), setCardinality("?", createGroup(createKeyword("("), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS)), createKeyword(")")))));
			PR_CollectionTypeIdentifier.setAlternatives(createAlternatives(createKeyword("Set"), createKeyword("Bag"), createKeyword("Sequence"), createKeyword("Collection"), createKeyword("OrderedSet")));
			PR_ConstructorPartCS.setAlternatives(createGroup(createAssignment("referredProperty", "=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.PROPERTY), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), createKeyword("="), createAssignment("ownedInitExpression", "=", createAlternatives(createRuleCall(PR_ExpCS), createRuleCall(PR_PatternExpCS)))));
			PR_CurlyBracketedClauseCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.CURLY_BRACKETED_CLAUSE_CS)), createKeyword("{"), createAlternatives(setCardinality("?", createGroup(createAssignment("ownedParts", "+=", createRuleCall(PR_ConstructorPartCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedParts", "+=", createRuleCall(PR_ConstructorPartCS)))))), createAssignment("value", "=", createRuleCall(_Base.PR_StringLiteral))), createKeyword("}")));
			PR_ElseIfThenExpCS.setAlternatives(createGroup(createKeyword("elseif"), createAssignment("ownedCondition", "=", createRuleCall(PR_ExpCS)), createKeyword("then"), createAssignment("ownedThenExpression", "=", createRuleCall(PR_ExpCS))));
			PR_EssentialOCLInfixOperatorName.setAlternatives(createAlternatives(createKeyword("*"), createKeyword("/"), createKeyword("+"), createKeyword("-"), createKeyword(">"), createKeyword("<"), createKeyword(">="), createKeyword("<="), createKeyword("="), createKeyword("<>"), createKeyword("and"), createKeyword("or"), createKeyword("xor"), createKeyword("implies")));
			PR_EssentialOCLNavigationOperatorName.setAlternatives(createAlternatives(createKeyword("."), createKeyword("->"), createKeyword("?."), createKeyword("?->")));
			PR_EssentialOCLReservedKeyword.setAlternatives(createAlternatives(createKeyword("and"), createKeyword("else"), createKeyword("endif"), createKeyword("if"), createKeyword("implies"), createKeyword("in"), createKeyword("let"), createKeyword("not"), createKeyword("or"), createKeyword("then"), createKeyword("xor")));
			PR_EssentialOCLUnaryOperatorName.setAlternatives(createAlternatives(createKeyword("-"), createKeyword("not")));
			PR_EssentialOCLUnreservedName.setAlternatives(createAlternatives(createRuleCall(_QVTcoreBase.PR_UnrestrictedName), createRuleCall(PR_CollectionTypeIdentifier), createRuleCall(PR_PrimitiveTypeIdentifier), createKeyword("Tuple")));
			PR_EssentialOCLUnrestrictedName.setAlternatives(createRuleCall(_Base.PR_Identifier));
			PR_ExpCS.setAlternatives(createAlternatives(createGroup(createRuleCall(PR_PrefixedPrimaryExpCS), setCardinality("?", createGroup(createAction("ownedLeft", "=", createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.INFIX_EXP_CS)), createAssignment("name", "=", createRuleCall(PR_BinaryOperatorName)), createAssignment("ownedRight", "=", createRuleCall(PR_ExpCS))))), createRuleCall(PR_PrefixedLetExpCS)));
			PR_IfExpCS.setAlternatives(createGroup(createKeyword("if"), createAssignment("ownedCondition", "=", createAlternatives(createRuleCall(PR_ExpCS), createRuleCall(PR_PatternExpCS))), createKeyword("then"), createAssignment("ownedThenExpression", "=", createRuleCall(PR_ExpCS)), setCardinality("*", createAssignment("ownedIfThenExpressions", "+=", createRuleCall(PR_ElseIfThenExpCS))), createKeyword("else"), createAssignment("ownedElseExpression", "=", createRuleCall(PR_ExpCS)), createKeyword("endif")));
			PR_InfixOperatorName.setAlternatives(createRuleCall(PR_EssentialOCLInfixOperatorName));
			PR_InvalidLiteralExpCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.INVALID_LITERAL_EXP_CS)), createKeyword("invalid")));
			PR_LambdaLiteralExpCS.setAlternatives(createGroup(createKeyword("Lambda"), createKeyword("{"), createAssignment("ownedExpressionCS", "=", createRuleCall(PR_ExpCS)), createKeyword("}")));
			PR_LetExpCS.setAlternatives(createGroup(createKeyword("let"), createAssignment("ownedVariables", "+=", createRuleCall(PR_LetVariableCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedVariables", "+=", createRuleCall(PR_LetVariableCS)))), createKeyword("in"), createAssignment("ownedInExpression", "=", createRuleCall(PR_ExpCS))));
			PR_LetVariableCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(_QVTcoreBase.PR_UnrestrictedName)), setCardinality("?", createAssignment("ownedRoundBracketedClause", "=", createRuleCall(PR_RoundBracketedClauseCS))), setCardinality("?", createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS)))), createKeyword("="), createAssignment("ownedInitExpression", "=", createRuleCall(PR_ExpCS))));
			PR_Model.setAlternatives(createAssignment("ownedExpression", "=", createRuleCall(PR_ExpCS)));
			PR_NameExpCS.setAlternatives(createGroup(createAssignment("ownedPathName", "=", createRuleCall(_Base.PR_PathNameCS)), setCardinality("*", createAssignment("ownedSquareBracketedClauses", "+=", createRuleCall(PR_SquareBracketedClauseCS))), setCardinality("?", createAssignment("ownedRoundBracketedClause", "=", createRuleCall(PR_RoundBracketedClauseCS))), setCardinality("?", createAssignment("ownedCurlyBracketedClause", "=", createRuleCall(PR_CurlyBracketedClauseCS))), setCardinality("?", createGroup(createAssignment("isPre", "?=", createKeyword("@")), createKeyword("pre")))));
			PR_NavigatingArgCS.setAlternatives(createAlternatives(createGroup(createAssignment("ownedNameExpression", "=", createRuleCall(PR_NavigatingArgExpCS)), setCardinality("?", createAlternatives(createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS)), setCardinality("?", createGroup(createKeyword("="), createAssignment("ownedInitExpression", "=", createRuleCall(PR_ExpCS))))), createGroup(createKeyword("in"), createAssignment("ownedInitExpression", "=", createRuleCall(PR_ExpCS)))))), createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS)))));
			PR_NavigatingArgExpCS.setAlternatives(createRuleCall(PR_ExpCS));
			PR_NavigatingBarArgCS.setAlternatives(createGroup(createAssignment("prefix", "=", createKeyword("|")), createAssignment("ownedNameExpression", "=", createRuleCall(PR_NavigatingArgExpCS)), setCardinality("?", createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS)), setCardinality("?", createGroup(createKeyword("="), createAssignment("ownedInitExpression", "=", createRuleCall(PR_ExpCS))))))));
			PR_NavigatingCommaArgCS.setAlternatives(createGroup(createAssignment("prefix", "=", createKeyword(",")), createAssignment("ownedNameExpression", "=", createRuleCall(PR_NavigatingArgExpCS)), setCardinality("?", createAlternatives(createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS)), setCardinality("?", createGroup(createKeyword("="), createAssignment("ownedInitExpression", "=", createRuleCall(PR_ExpCS))))), createGroup(createKeyword("in"), createAssignment("ownedInitExpression", "=", createRuleCall(PR_ExpCS)))))));
			PR_NavigatingSemiArgCS.setAlternatives(createGroup(createAssignment("prefix", "=", createKeyword(";")), createAssignment("ownedNameExpression", "=", createRuleCall(PR_NavigatingArgExpCS)), setCardinality("?", createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS)), setCardinality("?", createGroup(createKeyword("="), createAssignment("ownedInitExpression", "=", createRuleCall(PR_ExpCS))))))));
			PR_NavigationOperatorName.setAlternatives(createRuleCall(PR_EssentialOCLNavigationOperatorName));
			PR_NestedExpCS.setAlternatives(createGroup(createKeyword("("), createAssignment("ownedExpression", "=", createRuleCall(PR_ExpCS)), createKeyword(")")));
			PR_NullLiteralExpCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.NULL_LITERAL_EXP_CS)), createKeyword("null")));
			PR_NumberLiteralExpCS.setAlternatives(createAssignment("symbol", "=", createRuleCall(_Base.PR_NUMBER_LITERAL)));
			PR_PatternExpCS.setAlternatives(createGroup(setCardinality("?", createAssignment("patternVariableName", "=", createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), createKeyword(":"), createAssignment("ownedPatternType", "=", createRuleCall(PR_TypeExpCS))));
			PR_PrefixedLetExpCS.setAlternatives(createAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.PREFIX_EXP_CS)), createAssignment("name", "=", createRuleCall(PR_UnaryOperatorName)), createAssignment("ownedRight", "=", createRuleCall(PR_PrefixedLetExpCS))), createRuleCall(PR_LetExpCS)));
			PR_PrefixedPrimaryExpCS.setAlternatives(createAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.PREFIX_EXP_CS)), createAssignment("name", "=", createRuleCall(PR_UnaryOperatorName)), createAssignment("ownedRight", "=", createRuleCall(PR_PrefixedPrimaryExpCS))), createRuleCall(PR_PrimaryExpCS)));
			PR_PrimaryExpCS.setAlternatives(createAlternatives(createRuleCall(PR_NestedExpCS), createRuleCall(PR_IfExpCS), createRuleCall(PR_SelfExpCS), createRuleCall(PR_PrimitiveLiteralExpCS), createRuleCall(PR_TupleLiteralExpCS), createRuleCall(PR_CollectionLiteralExpCS), createRuleCall(PR_LambdaLiteralExpCS), createRuleCall(PR_TypeLiteralExpCS), createRuleCall(PR_NameExpCS)));
			PR_PrimitiveLiteralExpCS.setAlternatives(createAlternatives(createRuleCall(PR_NumberLiteralExpCS), createRuleCall(PR_StringLiteralExpCS), createRuleCall(PR_BooleanLiteralExpCS), createRuleCall(PR_UnlimitedNaturalLiteralExpCS), createRuleCall(PR_InvalidLiteralExpCS), createRuleCall(PR_NullLiteralExpCS)));
			PR_PrimitiveTypeCS.setAlternatives(createAssignment("name", "=", createRuleCall(PR_PrimitiveTypeIdentifier)));
			PR_PrimitiveTypeIdentifier.setAlternatives(createAlternatives(createKeyword("Boolean"), createKeyword("Integer"), createKeyword("Real"), createKeyword("String"), createKeyword("UnlimitedNatural"), createKeyword("OclAny"), createKeyword("OclInvalid"), createKeyword("OclVoid")));
			PR_RoundBracketedClauseCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.ROUND_BRACKETED_CLAUSE_CS)), createKeyword("("), setCardinality("?", createGroup(createAssignment("ownedArguments", "+=", createRuleCall(PR_NavigatingArgCS)), setCardinality("*", createAssignment("ownedArguments", "+=", createRuleCall(PR_NavigatingCommaArgCS))), setCardinality("?", createGroup(createAssignment("ownedArguments", "+=", createRuleCall(PR_NavigatingSemiArgCS)), setCardinality("*", createAssignment("ownedArguments", "+=", createRuleCall(PR_NavigatingCommaArgCS))))), setCardinality("*", createGroup(createAssignment("ownedArguments", "+=", createRuleCall(PR_NavigatingBarArgCS)), setCardinality("*", createAssignment("ownedArguments", "+=", createRuleCall(PR_NavigatingCommaArgCS))))))), createKeyword(")")));
			PR_SelfExpCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.SELF_EXP_CS)), createKeyword("self")));
			PR_SquareBracketedClauseCS.setAlternatives(createGroup(createKeyword("["), createAssignment("ownedTerms", "+=", createRuleCall(PR_ExpCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedTerms", "+=", createRuleCall(PR_ExpCS)))), createKeyword("]")));
			PR_StringLiteralExpCS.setAlternatives(setCardinality("+", createAssignment("segments", "+=", createRuleCall(_Base.PR_StringLiteral))));
			PR_TupleLiteralExpCS.setAlternatives(createGroup(createKeyword("Tuple"), createKeyword("{"), createAssignment("ownedParts", "+=", createRuleCall(PR_TupleLiteralPartCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedParts", "+=", createRuleCall(PR_TupleLiteralPartCS)))), createKeyword("}")));
			PR_TupleLiteralPartCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(_QVTcoreBase.PR_UnrestrictedName)), setCardinality("?", createGroup(createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS)))), createKeyword("="), createAssignment("ownedInitExpression", "=", createRuleCall(PR_ExpCS))));
			PR_TuplePartCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(_QVTcoreBase.PR_UnrestrictedName)), createKeyword(":"), createAssignment("ownedType", "=", createRuleCall(PR_TypeExpCS))));
			PR_TupleTypeCS.setAlternatives(createGroup(createAssignment("name", "=", createKeyword("Tuple")), setCardinality("?", createGroup(createKeyword("("), setCardinality("?", createGroup(createAssignment("ownedParts", "+=", createRuleCall(PR_TuplePartCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedParts", "+=", createRuleCall(PR_TuplePartCS)))))), createKeyword(")")))));
			PR_TypeExpCS.setAlternatives(createGroup(createAlternatives(createRuleCall(PR_TypeNameExpCS), createRuleCall(PR_TypeLiteralCS), createRuleCall(PR_CollectionPatternCS)), setCardinality("?", createAssignment("ownedMultiplicity", "=", createRuleCall(_Base.PR_MultiplicityCS)))));
			PR_TypeLiteralCS.setAlternatives(createAlternatives(createRuleCall(PR_PrimitiveTypeCS), createRuleCall(PR_CollectionTypeCS), createRuleCall(PR_TupleTypeCS)));
			PR_TypeLiteralExpCS.setAlternatives(createAssignment("ownedType", "=", createRuleCall(PR_TypeLiteralWithMultiplicityCS)));
			PR_TypeLiteralWithMultiplicityCS.setAlternatives(createGroup(createRuleCall(PR_TypeLiteralCS), setCardinality("?", createAssignment("ownedMultiplicity", "=", createRuleCall(_Base.PR_MultiplicityCS)))));
			PR_TypeNameExpCS.setAlternatives(createGroup(createAssignment("ownedPathName", "=", createRuleCall(_Base.PR_PathNameCS)), setCardinality("?", createGroup(createAssignment("ownedCurlyBracketedClause", "=", createRuleCall(PR_CurlyBracketedClauseCS)), setCardinality("?", createGroup(createKeyword("{"), createAssignment("ownedPatternGuard", "=", createRuleCall(PR_ExpCS)), createKeyword("}")))))));
			PR_URIFirstPathElementCS.setAlternatives(createAlternatives(createAssignment("referredElement", "=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.NAMED_ELEMENT), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))), createGroup(createAction(null, null, createTypeRef(MM_base, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.PATH_ELEMENT_WITH_URICS)), createAssignment("referredElement", "=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.NAMESPACE), createRuleCall(_Base.PR_URI))))));
			PR_URIPathNameCS.setAlternatives(createGroup(createAssignment("ownedPathElements", "+=", createRuleCall(PR_URIFirstPathElementCS)), setCardinality("*", createGroup(createKeyword("::"), createAssignment("ownedPathElements", "+=", createRuleCall(_Base.PR_NextPathElementCS))))));
			PR_UnaryOperatorName.setAlternatives(createRuleCall(PR_EssentialOCLUnaryOperatorName));
			PR_UnlimitedNaturalLiteralExpCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage.Literals.UNLIMITED_NATURAL_LITERAL_EXP_CS)), createKeyword("*")));
			PR_UnreservedName.setAlternatives(createRuleCall(PR_EssentialOCLUnreservedName));
			PR_UnrestrictedName.setAlternatives(createRuleCall(PR_EssentialOCLUnrestrictedName));
		}
		
		private static @NonNull Grammar initGrammar() {
			initParserRules();
			Grammar grammar = G_EssentialOCL;
			{
				List<AbstractMetamodelDeclaration> metamodelDeclarations = grammar.getMetamodelDeclarations();
				metamodelDeclarations.add(MM_ecore);
				metamodelDeclarations.add(MM_pivot);
				metamodelDeclarations.add(MM_base);
				metamodelDeclarations.add(MM);
			}
			{
				List<AbstractRule> rules = grammar.getRules();
				rules.add(PR_Model);
				rules.add(PR_EssentialOCLReservedKeyword);
				rules.add(PR_EssentialOCLUnaryOperatorName);
				rules.add(PR_EssentialOCLInfixOperatorName);
				rules.add(PR_EssentialOCLNavigationOperatorName);
				rules.add(PR_BinaryOperatorName);
				rules.add(PR_InfixOperatorName);
				rules.add(PR_NavigationOperatorName);
				rules.add(PR_UnaryOperatorName);
				rules.add(PR_EssentialOCLUnrestrictedName);
				rules.add(PR_UnrestrictedName);
				rules.add(PR_EssentialOCLUnreservedName);
				rules.add(PR_UnreservedName);
				rules.add(PR_URIPathNameCS);
				rules.add(PR_URIFirstPathElementCS);
				rules.add(PR_PrimitiveTypeIdentifier);
				rules.add(PR_PrimitiveTypeCS);
				rules.add(PR_CollectionTypeIdentifier);
				rules.add(PR_CollectionTypeCS);
				rules.add(PR_TupleTypeCS);
				rules.add(PR_TuplePartCS);
				rules.add(PR_CollectionLiteralExpCS);
				rules.add(PR_CollectionLiteralPartCS);
				rules.add(PR_CollectionPatternCS);
				rules.add(PR_ConstructorPartCS);
				rules.add(PR_PatternExpCS);
				rules.add(PR_LambdaLiteralExpCS);
				rules.add(PR_PrimitiveLiteralExpCS);
				rules.add(PR_TupleLiteralExpCS);
				rules.add(PR_TupleLiteralPartCS);
				rules.add(PR_NumberLiteralExpCS);
				rules.add(PR_StringLiteralExpCS);
				rules.add(PR_BooleanLiteralExpCS);
				rules.add(PR_UnlimitedNaturalLiteralExpCS);
				rules.add(PR_InvalidLiteralExpCS);
				rules.add(PR_NullLiteralExpCS);
				rules.add(PR_TypeLiteralCS);
				rules.add(PR_TypeLiteralWithMultiplicityCS);
				rules.add(PR_TypeLiteralExpCS);
				rules.add(PR_TypeNameExpCS);
				rules.add(PR_TypeExpCS);
				rules.add(PR_ExpCS);
				rules.add(PR_PrefixedLetExpCS);
				rules.add(PR_PrefixedPrimaryExpCS);
				rules.add(PR_PrimaryExpCS);
				rules.add(PR_NameExpCS);
				rules.add(PR_CurlyBracketedClauseCS);
				rules.add(PR_RoundBracketedClauseCS);
				rules.add(PR_SquareBracketedClauseCS);
				rules.add(PR_NavigatingArgCS);
				rules.add(PR_NavigatingBarArgCS);
				rules.add(PR_NavigatingCommaArgCS);
				rules.add(PR_NavigatingSemiArgCS);
				rules.add(PR_NavigatingArgExpCS);
				rules.add(PR_IfExpCS);
				rules.add(PR_ElseIfThenExpCS);
				rules.add(PR_LetExpCS);
				rules.add(PR_LetVariableCS);
				rules.add(PR_NestedExpCS);
				rules.add(PR_SelfExpCS);
			}
			{
				List<Grammar> usedGrammars = grammar.getUsedGrammars();
				usedGrammars.add(G_Base);
			}
			return grammar;
		}
	}
	
	private static class _Base
	{
		private static final @NonNull ReferencedMetamodel MM = createReferencedMetamodel(org.eclipse.ocl.xtext.basecs.BaseCSPackage.eINSTANCE, null); // http://www.eclipse.org/ocl/2015/BaseCS
		private static final @NonNull ReferencedMetamodel MM_ecore = createReferencedMetamodel(org.eclipse.emf.ecore.EcorePackage.eINSTANCE, "ecore"); // http://www.eclipse.org/emf/2002/Ecore
		private static final @NonNull ReferencedMetamodel MM_pivot = createReferencedMetamodel(org.eclipse.ocl.pivot.PivotPackage.eINSTANCE, "pivot"); // http://www.eclipse.org/ocl/2015/Pivot
		
		private static final @NonNull TerminalRule TR_ANY_OTHER = createTerminalRule("ANY_OTHER", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_DOUBLE_QUOTED_STRING = createTerminalRule("DOUBLE_QUOTED_STRING", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_ESCAPED_CHARACTER = createTerminalRule("ESCAPED_CHARACTER", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_ESCAPED_ID = createTerminalRule("ESCAPED_ID", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_INT = createTerminalRule("INT", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_LETTER_CHARACTER = createTerminalRule("LETTER_CHARACTER", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_ML_COMMENT = createTerminalRule("ML_COMMENT", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_ML_SINGLE_QUOTED_STRING = createTerminalRule("ML_SINGLE_QUOTED_STRING", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_SIMPLE_ID = createTerminalRule("SIMPLE_ID", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_SINGLE_QUOTED_STRING = createTerminalRule("SINGLE_QUOTED_STRING", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_SL_COMMENT = createTerminalRule("SL_COMMENT", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull TerminalRule TR_WS = createTerminalRule("WS", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		
		private static void initTerminalRules() {
			TR_ANY_OTHER.setAlternatives(createWildcard());
			TR_DOUBLE_QUOTED_STRING.setAlternatives(createGroup(createKeyword("\""), setCardinality("*", createAlternatives(createRuleCall(TR_ESCAPED_CHARACTER), createNegatedToken(createAlternatives(createKeyword("\\"), createKeyword("\""))))), createKeyword("\"")));
			TR_ESCAPED_CHARACTER.setFragment(true);
			TR_ESCAPED_CHARACTER.setAlternatives(createGroup(createKeyword("\\"), createAlternatives(createKeyword("b"), createKeyword("t"), createKeyword("n"), createKeyword("f"), createKeyword("r"), createKeyword("u"), createKeyword("\""), createKeyword("\'"), createKeyword("\\"))));
			TR_ESCAPED_ID.setAlternatives(createGroup(createKeyword("_"), createRuleCall(TR_SINGLE_QUOTED_STRING)));
			TR_INT.setAlternatives(setCardinality("+", createCharacterRange(createKeyword("0"), createKeyword("9"))));
			TR_LETTER_CHARACTER.setFragment(true);
			TR_LETTER_CHARACTER.setAlternatives(createAlternatives(createCharacterRange(createKeyword("a"), createKeyword("z")), createCharacterRange(createKeyword("A"), createKeyword("Z")), createKeyword("_")));
			TR_ML_COMMENT.setAlternatives(createGroup(createKeyword("/*"), createUntilToken(createKeyword("*/"))));
			TR_ML_SINGLE_QUOTED_STRING.setAlternatives(createGroup(createKeyword("/\'"), createUntilToken(createKeyword("\'/"))));
			TR_SIMPLE_ID.setAlternatives(createGroup(createRuleCall(TR_LETTER_CHARACTER), setCardinality("*", createAlternatives(createRuleCall(TR_LETTER_CHARACTER), createCharacterRange(createKeyword("0"), createKeyword("9"))))));
			TR_SINGLE_QUOTED_STRING.setAlternatives(createGroup(createKeyword("\'"), setCardinality("*", createAlternatives(createRuleCall(TR_ESCAPED_CHARACTER), createNegatedToken(createAlternatives(createKeyword("\\"), createKeyword("\'"))))), createKeyword("\'")));
			TR_SL_COMMENT.setAlternatives(createGroup(createKeyword("--"), setCardinality("*", createNegatedToken(createAlternatives(createKeyword("\n"), createKeyword("\r")))), setCardinality("?", createGroup(setCardinality("?", createKeyword("\r")), createKeyword("\n")))));
			TR_WS.setAlternatives(setCardinality("+", createAlternatives(createKeyword(" "), createKeyword("\t"), createKeyword("\r"), createKeyword("\n"))));
		}
		
		private static final @NonNull ParserRule PR_FirstPathElementCS = createParserRule("FirstPathElementCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.PATH_ELEMENT_CS));
		private static final @NonNull ParserRule PR_ID = createParserRule("ID", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_Identifier = createParserRule("Identifier", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_LOWER = createParserRule("LOWER", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.EINT));
		private static final @NonNull ParserRule PR_MultiplicityBoundsCS = createParserRule("MultiplicityBoundsCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.MULTIPLICITY_BOUNDS_CS));
		private static final @NonNull ParserRule PR_MultiplicityCS = createParserRule("MultiplicityCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.MULTIPLICITY_CS));
		private static final @NonNull ParserRule PR_MultiplicityStringCS = createParserRule("MultiplicityStringCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.MULTIPLICITY_STRING_CS));
		private static final @NonNull ParserRule PR_NUMBER_LITERAL = createParserRule("NUMBER_LITERAL", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.BIG_NUMBER));
		private static final @NonNull ParserRule PR_NextPathElementCS = createParserRule("NextPathElementCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.PATH_ELEMENT_CS));
		private static final @NonNull ParserRule PR_PathNameCS = createParserRule("PathNameCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.PATH_NAME_CS));
		private static final @NonNull ParserRule PR_StringLiteral = createParserRule("StringLiteral", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_TemplateBindingCS = createParserRule("TemplateBindingCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TEMPLATE_BINDING_CS));
		private static final @NonNull ParserRule PR_TemplateParameterSubstitutionCS = createParserRule("TemplateParameterSubstitutionCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TEMPLATE_PARAMETER_SUBSTITUTION_CS));
		private static final @NonNull ParserRule PR_TemplateSignatureCS = createParserRule("TemplateSignatureCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TEMPLATE_SIGNATURE_CS));
		private static final @NonNull ParserRule PR_TypeParameterCS = createParserRule("TypeParameterCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TYPE_PARAMETER_CS));
		private static final @NonNull ParserRule PR_TypeRefCS = createParserRule("TypeRefCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TYPE_REF_CS));
		private static final @NonNull ParserRule PR_TypedRefCS = createParserRule("TypedRefCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TYPED_REF_CS));
		private static final @NonNull ParserRule PR_TypedTypeRefCS = createParserRule("TypedTypeRefCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.TYPED_TYPE_REF_CS));
		private static final @NonNull ParserRule PR_UPPER = createParserRule("UPPER", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.EINT));
		private static final @NonNull ParserRule PR_URI = createParserRule("URI", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_UnreservedName = createParserRule("UnreservedName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_UnrestrictedName = createParserRule("UnrestrictedName", createTypeRef(MM_ecore, org.eclipse.emf.ecore.EcorePackage.Literals.ESTRING));
		private static final @NonNull ParserRule PR_WildcardTypeRefCS = createParserRule("WildcardTypeRefCS", createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.WILDCARD_TYPE_REF_CS));
		
		private static void initParserRules() {
			PR_FirstPathElementCS.setAlternatives(createAssignment("referredElement", "=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.NAMED_ELEMENT), createRuleCall(_QVTcoreBase.PR_UnrestrictedName))));
			PR_ID.setAlternatives(createAlternatives(createRuleCall(TR_SIMPLE_ID), createRuleCall(TR_ESCAPED_ID)));
			PR_Identifier.setAlternatives(createRuleCall(PR_ID));
			PR_LOWER.setAlternatives(createRuleCall(TR_INT));
			PR_MultiplicityBoundsCS.setAlternatives(createGroup(createAssignment("lowerBound", "=", createRuleCall(PR_LOWER)), setCardinality("?", createGroup(createKeyword(".."), createAssignment("upperBound", "=", createRuleCall(PR_UPPER))))));
			PR_MultiplicityCS.setAlternatives(createGroup(createKeyword("["), createAlternatives(createRuleCall(PR_MultiplicityBoundsCS), createRuleCall(PR_MultiplicityStringCS)), createKeyword("]")));
			PR_MultiplicityStringCS.setAlternatives(createAssignment("stringBounds", "=", createAlternatives(createKeyword("*"), createKeyword("+"), createKeyword("?"))));
			PR_NUMBER_LITERAL.setAlternatives(createRuleCall(TR_INT));
			PR_NextPathElementCS.setAlternatives(createAssignment("referredElement", "=", createCrossReference(createTypeRef(MM_pivot, org.eclipse.ocl.pivot.PivotPackage.Literals.NAMED_ELEMENT), createRuleCall(_EssentialOCL.PR_UnreservedName))));
			PR_PathNameCS.setAlternatives(createGroup(createAssignment("ownedPathElements", "+=", createRuleCall(PR_FirstPathElementCS)), setCardinality("*", createGroup(createKeyword("::"), createAssignment("ownedPathElements", "+=", createRuleCall(PR_NextPathElementCS))))));
			PR_StringLiteral.setAlternatives(createRuleCall(TR_SINGLE_QUOTED_STRING));
			PR_TemplateBindingCS.setAlternatives(createGroup(createKeyword("("), createAssignment("ownedSubstitutions", "+=", createRuleCall(PR_TemplateParameterSubstitutionCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedSubstitutions", "+=", createRuleCall(PR_TemplateParameterSubstitutionCS)))), createKeyword(")")));
			PR_TemplateParameterSubstitutionCS.setAlternatives(createAssignment("ownedActualParameter", "=", createRuleCall(PR_TypeRefCS)));
			PR_TemplateSignatureCS.setAlternatives(createGroup(createKeyword("("), createAssignment("ownedParameters", "+=", createRuleCall(PR_TypeParameterCS)), setCardinality("*", createGroup(createKeyword(","), createAssignment("ownedParameters", "+=", createRuleCall(PR_TypeParameterCS)))), createKeyword(")")));
			PR_TypeParameterCS.setAlternatives(createGroup(createAssignment("name", "=", createRuleCall(_QVTcoreBase.PR_UnrestrictedName)), setCardinality("?", createAlternatives(createGroup(createKeyword("extends"), createAssignment("ownedExtends", "+=", createRuleCall(PR_TypedRefCS)), setCardinality("*", createGroup(createKeyword("&&"), createAssignment("ownedExtends", "+=", createRuleCall(PR_TypedRefCS))))), createGroup(createKeyword("super"), createAssignment("ownedSuper", "=", createRuleCall(PR_TypedRefCS)))))));
			PR_TypeRefCS.setAlternatives(createAlternatives(createRuleCall(PR_TypedRefCS), createRuleCall(PR_WildcardTypeRefCS)));
			PR_TypedRefCS.setAlternatives(createRuleCall(PR_TypedTypeRefCS));
			PR_TypedTypeRefCS.setAlternatives(createGroup(createAssignment("ownedPathName", "=", createRuleCall(PR_PathNameCS)), setCardinality("?", createAssignment("ownedBinding", "=", createRuleCall(PR_TemplateBindingCS)))));
			PR_UPPER.setAlternatives(createAlternatives(createRuleCall(TR_INT), createKeyword("*")));
			PR_URI.setAlternatives(createRuleCall(TR_SINGLE_QUOTED_STRING));
			PR_UnreservedName.setAlternatives(createRuleCall(_QVTcoreBase.PR_UnrestrictedName));
			PR_UnrestrictedName.setAlternatives(createRuleCall(PR_Identifier));
			PR_WildcardTypeRefCS.setAlternatives(createGroup(createAction(null, null, createTypeRef(MM, org.eclipse.ocl.xtext.basecs.BaseCSPackage.Literals.WILDCARD_TYPE_REF_CS)), createKeyword("?"), setCardinality("?", createAlternatives(createGroup(createKeyword("extends"), createAssignment("ownedExtends", "=", createRuleCall(PR_TypedRefCS))), createGroup(createKeyword("super"), createAssignment("ownedSuper", "=", createRuleCall(PR_TypedRefCS)))))));
		}
		
		private static @NonNull Grammar initGrammar() {
			initTerminalRules();
			initParserRules();
			Grammar grammar = G_Base;
			grammar.setDefinesHiddenTokens(true);
			{
				List<AbstractMetamodelDeclaration> metamodelDeclarations = grammar.getMetamodelDeclarations();
				metamodelDeclarations.add(MM_ecore);
				metamodelDeclarations.add(MM_pivot);
				metamodelDeclarations.add(MM);
			}
			{
				List<AbstractRule> rules = grammar.getRules();
				rules.add(PR_MultiplicityBoundsCS);
				rules.add(PR_MultiplicityCS);
				rules.add(PR_MultiplicityStringCS);
				rules.add(PR_PathNameCS);
				rules.add(PR_FirstPathElementCS);
				rules.add(PR_NextPathElementCS);
				rules.add(PR_TemplateBindingCS);
				rules.add(PR_TemplateParameterSubstitutionCS);
				rules.add(PR_TemplateSignatureCS);
				rules.add(PR_TypeParameterCS);
				rules.add(PR_TypeRefCS);
				rules.add(PR_TypedRefCS);
				rules.add(PR_TypedTypeRefCS);
				rules.add(PR_UnreservedName);
				rules.add(PR_UnrestrictedName);
				rules.add(PR_WildcardTypeRefCS);
				rules.add(PR_ID);
				rules.add(PR_Identifier);
				rules.add(PR_LOWER);
				rules.add(PR_NUMBER_LITERAL);
				rules.add(PR_StringLiteral);
				rules.add(PR_UPPER);
				rules.add(PR_URI);
				rules.add(TR_ESCAPED_CHARACTER);
				rules.add(TR_LETTER_CHARACTER);
				rules.add(TR_DOUBLE_QUOTED_STRING);
				rules.add(TR_SINGLE_QUOTED_STRING);
				rules.add(TR_ML_SINGLE_QUOTED_STRING);
				rules.add(TR_SIMPLE_ID);
				rules.add(TR_ESCAPED_ID);
				rules.add(TR_INT);
				rules.add(TR_ML_COMMENT);
				rules.add(TR_SL_COMMENT);
				rules.add(TR_WS);
				rules.add(TR_ANY_OTHER);
			}
			{
				List<AbstractRule> hiddenTokens = grammar.getHiddenTokens();
				hiddenTokens.add(TR_WS);
				hiddenTokens.add(TR_ML_COMMENT);
				hiddenTokens.add(TR_SL_COMMENT);
			}
			return grammar;
		}
	}
}